From 3c3d04af2aebc976f7c054f8fadf5f82cbb14fd2 Mon Sep 17 00:00:00 2001
From: Shai Almog <67850168+shai-almog@users.noreply.github.com>
Date: Fri, 2 Oct 2026 06:51:01 +0300
Subject: [PATCH 1/3] Add October 2 release blog series and benchmark visuals
---
.../img/backend-build-pipeline.svg | 2 +-
.../content/blog/browser-desktop-theme.md | 100 ++++
.../blog/friday-release-better-gates.md | 113 +++++
.../content/blog/gradle-smaller-projects.md | 182 ++++++++
.../blog/ios27-glass-from-measurements.md | 137 ++++++
.../blog/java-server-work-before-startup.md | 429 ++++++++++++++++++
.../blog/native-backend-observability.md | 210 +++++++++
.../content/blog/parparvm-four-byte-header.md | 164 +++++++
.../static/blog/browser-desktop-theme.jpg | Bin 0 -> 65333 bytes
.../static/blog/desktop-theme-collage.jpg | Bin 0 -> 244587 bytes
.../blog/friday-release-better-gates.jpg | Bin 0 -> 41015 bytes
.../static/blog/gradle-smaller-projects.jpg | Bin 0 -> 62015 bytes
.../blog/ios27-glass-from-measurements.jpg | Bin 0 -> 45604 bytes
.../blog/ios27-measured-glass/dark-poster.jpg | Bin 0 -> 34631 bytes
.../static/blog/ios27-measured-glass/dark.mp4 | Bin 0 -> 5342317 bytes
.../blog/ios27-measured-glass/light.mp4 | Bin 0 -> 5432530 bytes
.../blog/java-server-work-before-startup.jpg | Bin 0 -> 45379 bytes
.../blog/native-backend-observability.jpg | Bin 0 -> 40307 bytes
.../blog/native-http-charts/binary-size.png | Bin 0 -> 70656 bytes
.../blog/native-http-charts/build-time.png | Bin 0 -> 133356 bytes
.../static/blog/native-http-charts/memory.png | Bin 0 -> 227892 bytes
.../blog/native-http-charts/startup.png | Bin 0 -> 89450 bytes
.../blog/native-http-charts/throughput.png | Bin 0 -> 164376 bytes
.../native-http-charts/warmed-throughput.png | Bin 0 -> 147648 bytes
.../static/blog/native-http-comparison.zip | Bin 0 -> 383098 bytes
.../static/blog/parparvm-four-byte-header.jpg | Bin 0 -> 86017 bytes
.../blog/runtime-diagrams/arm64-baselines.png | Bin 0 -> 193237 bytes
.../blog/runtime-diagrams/damped-spring.svg | 268 +++++++++++
.../blog/runtime-diagrams/object-header.svg | 1 +
.../translation-baselines.png | Bin 0 -> 118444 bytes
30 files changed, 1605 insertions(+), 1 deletion(-)
create mode 100644 docs/website/content/blog/browser-desktop-theme.md
create mode 100644 docs/website/content/blog/friday-release-better-gates.md
create mode 100644 docs/website/content/blog/gradle-smaller-projects.md
create mode 100644 docs/website/content/blog/ios27-glass-from-measurements.md
create mode 100644 docs/website/content/blog/java-server-work-before-startup.md
create mode 100644 docs/website/content/blog/native-backend-observability.md
create mode 100644 docs/website/content/blog/parparvm-four-byte-header.md
create mode 100644 docs/website/static/blog/browser-desktop-theme.jpg
create mode 100644 docs/website/static/blog/desktop-theme-collage.jpg
create mode 100644 docs/website/static/blog/friday-release-better-gates.jpg
create mode 100644 docs/website/static/blog/gradle-smaller-projects.jpg
create mode 100644 docs/website/static/blog/ios27-glass-from-measurements.jpg
create mode 100644 docs/website/static/blog/ios27-measured-glass/dark-poster.jpg
create mode 100644 docs/website/static/blog/ios27-measured-glass/dark.mp4
create mode 100644 docs/website/static/blog/ios27-measured-glass/light.mp4
create mode 100644 docs/website/static/blog/java-server-work-before-startup.jpg
create mode 100644 docs/website/static/blog/native-backend-observability.jpg
create mode 100644 docs/website/static/blog/native-http-charts/binary-size.png
create mode 100644 docs/website/static/blog/native-http-charts/build-time.png
create mode 100644 docs/website/static/blog/native-http-charts/memory.png
create mode 100644 docs/website/static/blog/native-http-charts/startup.png
create mode 100644 docs/website/static/blog/native-http-charts/throughput.png
create mode 100644 docs/website/static/blog/native-http-charts/warmed-throughput.png
create mode 100644 docs/website/static/blog/native-http-comparison.zip
create mode 100644 docs/website/static/blog/parparvm-four-byte-header.jpg
create mode 100644 docs/website/static/blog/runtime-diagrams/arm64-baselines.png
create mode 100644 docs/website/static/blog/runtime-diagrams/damped-spring.svg
create mode 100644 docs/website/static/blog/runtime-diagrams/object-header.svg
create mode 100644 docs/website/static/blog/runtime-diagrams/translation-baselines.png
diff --git a/docs/developer-guide/img/backend-build-pipeline.svg b/docs/developer-guide/img/backend-build-pipeline.svg
index 96e48244585..ab3a307fb35 100644
--- a/docs/developer-guide/img/backend-build-pipeline.svg
+++ b/docs/developer-guide/img/backend-build-pipeline.svg
@@ -9,7 +9,7 @@
@RestControllercontrollers
- @Service @Component
+ @Componentbeans@Configuration + @Bean
diff --git a/docs/website/content/blog/browser-desktop-theme.md b/docs/website/content/blog/browser-desktop-theme.md
new file mode 100644
index 00000000000..87a58ef6d53
--- /dev/null
+++ b/docs/website/content/blog/browser-desktop-theme.md
@@ -0,0 +1,100 @@
+---
+title: "Do You Want Your Web App to Feel Like a Native App?"
+slug: browser-desktop-theme
+url: /blog/browser-desktop-theme/
+date: '2026-10-07'
+author: Shai Almog
+description: "Use macOS, Windows or Linux desktop styling in the JavaScript port, with an optional HTML menu bar, and see how the same theme work reaches the Certificate Wizard."
+feed_html: ' Use macOS, Windows or Linux desktop styling in the JavaScript port, with an optional HTML menu bar, and see how the same theme work reaches the Certificate Wizard.'
+series: ["release-2026-10-02"]
+---
+
+
+
+You can give your Codename One web app the same desktop theme family as your users' operating system: Aqua on macOS, Fluent on Windows, or Adwaita on Linux. Menus can sit above the app in HTML, with commands such as File and View visible instead of tucked into a mobile overflow menu.
+
+That gives you a browser version of your app that fits more comfortably on a desktop. The JavaScript port now supports both choices, and the same theme work reaches the Certificate Wizard you use to sign your apps.
+
+## Follow the operating system, or choose a theme
+
+Set these in the Settings app's **Build Hints**:
+
+```properties
+nativeTheme=native
+javascript.titleBar=html
+```
+
+In `codenameone_settings.properties`, use `codename1.arg.nativeTheme` and `codename1.arg.javascript.titleBar` instead. Desktop browsers select Fluent for Windows, Aqua for macOS, and Adwaita for Linux and the remaining desktop systems. Phones and tablets keep the mobile theme selection. The browser detection treats an iPad as a tablet even when it reports a Mac browser.
+
+These are Codename One themes drawing the controls. They are not the operating system's native widget toolkit embedded in the page.
+
+[](/blog/desktop-theme-collage.jpg)
+
+*The Settings app demonstrates the three desktop theme families now available to browser apps. Click to compare the controls at full size.*
+
+You can pin a desktop theme when the application's design calls for it:
+
+```properties
+javascript.desktopTheme=fluent
+```
+
+The other explicit choices are `aqua`, `adwaita` and `none`. `none` keeps mobile themes on desktop browsers. Leave the value at `auto` to follow the operating system. The broader `nativeTheme=modern` setting has different behavior: it selects the modern mobile families, including on desktop browsers. Use `native` when desktop family selection is what you want.
+
+## Put commands above the app
+
+The default `javascript.titleBar=toolbar` keeps the themed Toolbar inside the app. With `html`, the page supplies title and menu bars instead. The title follows the current form; commands group into menus using the same `Command.setDesktopMenu()` hint used on the desktop ports.
+
+For example, inside an initialized app:
+
+```java
+com.codename1.ui.Form form = new com.codename1.ui.Form("Notes");
+com.codename1.ui.Command refresh = new com.codename1.ui.Command("Refresh") {
+ public void actionPerformed(com.codename1.ui.events.ActionEvent event) {
+ form.setTitle("Notes refreshed");
+ }
+};
+refresh.setDesktopMenu("View");
+form.getToolbar().addCommandToOverflowMenu(refresh);
+form.show();
+```
+
+Commands without a menu hint go into a **Commands** menu. The HTML bars follow the selected appearance and the browser's light or dark preference. They do not have fake minimize, maximize or close buttons: the page does not own the browser window. The browser tab title remains the application's display name.
+
+{{< mermaid >}}
+flowchart TD
+ Commands[Toolbar commands and menu hints] --> Mode{Title bar setting}
+ Mode -->|toolbar| Inside[Themed Toolbar inside the app]
+ Mode -->|html| Outside[HTML title and menu above the app]
+ Outside --> Action[Dispatch to the same Command]
+ Inside --> Action
+{{< /mermaid >}}
+
+The source is in [JavaScriptDesktopChrome](https://github.com/codenameone/CodenameOne/blob/master/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/JavaScriptDesktopChrome.java), with build-hint and page behavior documented in the [JavaScript guide](/developer-guide/working-with-javascript/).
+
+## Keep navigation inside your browser app
+
+We do not support additional native `Window` surfaces in the JavaScript port. Popup blockers and the browser's window ownership make that a different promise from drawing a menu inside the current page. **Windows browsers are supported; extra OS windows are the unsupported feature.** Dialogs and navigation within the app remain the appropriate model.
+
+There are renderer limits too. For example, the full lifted-lens optics from [Sunday's iOS article](/blog/ios27-glass-from-measurements/) are not implemented in the browser. Try the actual controls and effects your app uses rather than assuming a theme name proves complete renderer parity.
+
+The build prunes theme resources it can prove the app will not reach. If your code constructs resource names dynamically, set `javascript.pruneThemes=false`; otherwise a theme loaded only through that constructed name may be missing.
+
+## Use the same desktop styling when you sign your app
+
+A gallery of buttons cannot tell us whether an application works comfortably with a desktop theme. The Certificate Wizard has longer forms, tables, dialogs and instructions that people must actually read to finish a task.
+
+[PR #5916](https://github.com/codenameone/CodenameOne/pull/5916) adopts the native desktop themes there, continuing the work we did in Settings. Its current source uses `@DesktopBuild(themeMode = "native", titleBar = DesktopTitleBar.NATIVE, ...)`, with interactive scrollbars. Fluent, Aqua and Adwaita now provide the surrounding control styles instead of a separate wizard-specific desktop imitation.
+
+The same change fixes handling of an App ID's team prefix. That is a separate functional repair, not a consequence of adopting a theme. The wizard's [current source](https://github.com/codenameone/CodenameOne/tree/master/scripts/certificatewizard) keeps both changes visible.
+
+Try the browser theme with a form that has real commands and enough content to scroll. Switch appearances, open its menus and check keyboard navigation. That will teach you more than another screenshot of an isolated button.
+
+The [weekly overview](/blog/java-server-work-before-startup/) links the rest of the release. It also includes this week's smaller map-label improvement.
+
+---
+
+## Discussion
+
+_For a browser version of a desktop app, which commands deserve a visible menu?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/friday-release-better-gates.md b/docs/website/content/blog/friday-release-better-gates.md
new file mode 100644
index 00000000000..f54857f37d4
--- /dev/null
+++ b/docs/website/content/blog/friday-release-better-gates.md
@@ -0,0 +1,113 @@
+---
+title: "Don't Order Fish on Monday. Don't Release on Friday"
+slug: friday-release-better-gates
+url: /blog/friday-release-better-gates/
+date: '2026-10-08'
+author: Shai Almog
+description: "A difficult release week exposed an Apple API failure that passed device tests, leading to source and binary checks for undeclared SDK imports."
+feed_html: ' A difficult release week exposed an Apple API failure that passed device tests, leading to source and binary checks for undeclared SDK imports.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Anthony Bourdain's famous warning about Monday fish was a warning about the supply chain behind the menu. In his [1999 essay](https://www.newyorker.com/magazine/1999/04/19/dont-eat-before-reading-this), he described seafood bought for the weekend still being served on Monday. Knowing how the kitchen worked changed what he would order.
+
+Developers have a similar rule: never release on Friday. If something breaks, you have just made plans for everyone's weekend. It is excellent advice that we have ignored for years.
+
+We settled on Friday releases to avoid dropping a framework update into the middle of our customers' release week. The idea was to use the quieter window to test and repair our release before it collided with theirs. That assumes a lot about when other people ship. It has also cost me plenty of weekends.
+
+This time the problems consumed much of the week. There were regressions around the optional Xcode 27 path, push, and windows. Some overlapped, so a fix could make the original symptom disappear while the underlying problem resurfaced elsewhere. That is exhausting for us, and it is worse for the customer trying to finish an app.
+
+## Catch a rejection your device tests can miss
+
+One failure was especially instructive. Apps using particular crypto APIs could compile, link and run, then fail App Store Connect submission because the binary imported non-public symbols. Most apps did not enable the affected code, so most users and our usual tests never encountered it:
+
+```text
+_CCCryptorGCMAddAAD
+_CCCryptorGCMAddIV
+_CCCryptorGCMFinal
+```
+
+The SDK's libraries exported these symbols. The linker could resolve them. But they were not declared in the public headers. A successful link did not establish that they were public APIs suitable for submission.
+
+Our tests had another blind spot: the calls sat behind an optional feature gate that the sample app did not normally enable. Testing the same sample more often would not make that branch appear.
+
+The [new checker source](https://github.com/codenameone/CodenameOne/blob/master/scripts/check-ios-private-api.py) preserves the rejection and the causal chain. It is a more useful record than a claim that we “added more tests.”
+
+## How your build could enable a feature you never requested
+
+The builder enabled a feature by replacing a preprocessor definition. A plain string replacement for one name also matched the start of a longer name:
+
+```c
+#define CN1_INCLUDE_CRYPTO
+#define CN1_INCLUDE_CRYPTO_GCM
+```
+
+Enabling general crypto could therefore enable the GCM path too. The customer did not have to request that optional path to compile its imports.
+
+The fix makes the builder match the whole definition name. A focused regression test guards that behavior. The GCM implementation itself was rewritten using public CommonCrypto operations and a C implementation of GHASH, the authentication calculation. The authenticated-decryption path verifies the tag before releasing decrypted output.
+
+A separate sweep found `sqlite3_key` and `sqlite3_rekey` imports that were valid for the bundled cipher engine but not public declarations in Apple's SQLite headers. Those imports now depend on the bundled engine defining them. One rejected upload exposed more than one place where “the symbol links” had stood in for “the symbol is public.”
+
+## How we will catch this class of failure before it reaches you
+
+A regression test for the three names would catch those three names returning. We also need a check for the broader mistake: importing an SDK symbol that has no public declaration.
+
+The new gate asks that question in two ways:
+
+| Check | What it sees | Why it is needed |
+| --- | --- | --- |
+| Source mode | Native port sources with feature gates enabled and optional-engine variants | The ordinary sample does not exercise every feature combination |
+| Binary mode | Imports in a linked Release device app and the covered bundled components | The final link can contain code beyond the port source sweep |
+
+{{< mermaid >}}
+flowchart TD
+ Source[Native sources and feature variants] --> Compile[Compile the covered configurations]
+ Compile --> Imports[Collect SDK imports]
+ Binary[Linked Release device app] --> Imports
+ SDK[Public SDK headers] --> Compare[Compare exported names with declarations]
+ Imports --> Compare
+ Compare --> Fail[Fail on undeclared imported symbols]
+ Probe[Known private and public control symbols] --> Verify[Verify the checker can distinguish them]
+ Verify --> Compare
+{{< /mermaid >}}
+
+The checker uses SDK export information to identify the library symbols and scans public headers with comments removed. A name mentioned in a comment is not accepted as a declaration. It also exercises known private and public controls before trusting a clean result. A check that can never report a failure is a very comforting way to learn nothing.
+
+For a local inspection of a linked app, the script exposes a binary mode:
+
+```bash
+python3 scripts/check-ios-private-api.py \
+ --binary /path/to/Release-iphoneos/MyApp.app --sdk iphoneos
+```
+
+Replace the example path with your Release device artifact; use `--developer-dir` if the SDK belongs to a different Xcode installation. The repository wires source mode and Release binary mode into its iOS checks. [PR #5923](https://github.com/codenameone/CodenameOne/pull/5923) contains the implementation and the builder repair.
+
+## Know what your submission check covers
+
+This is an imported-symbol check for the covered C and Objective-C surface. It skips Swift and C++ mangled names that cannot be matched by this header scan, and it does not inspect private Objective-C selectors. The binary check in the repository runs against the covered sample and bundled components, not every arbitrary dependency a customer might add.
+
+It also cannot predict every App Store review decision. Entitlements, privacy declarations and application behavior are different questions. Checking imports catches one specific reason for rejection before you upload.
+
+Review those remaining checks separately when preparing your submission.
+
+## We owe you more reliable releases
+
+This week was hard. I spent too much of it chasing regressions, and some of you spent time proving to us that a fix had not really fixed your problem. That is time you should have been able to spend on your own apps. Our release process needs to do better.
+
+Changing the day we ship would not repair the gaps that let these failures through. Our plan is to strengthen the gates around the things we deliver: exercise optional configurations, check the final artifacts, and test rules that cover a whole class of mistakes. We still need the small regression test for each bug. We also need to ask why that bug could reach a customer while the checks were green.
+
+The private API gate is one concrete step in that plan. It checks feature combinations our regular sample missed, examines a linked Release app, and uses known control symbols to verify that the checker can actually fail. The wider work is ongoing; one new gate does not solve every regression involving Xcode, push, or windows.
+
+I cannot promise next week will be quiet. I can promise that a difficult week should leave us with stronger release checks, not just a longer list of closed bugs. As that coverage grows, fewer failures should depend on a customer finding the right combination of APIs for us.
+
+This closes the [weekly series](/blog/java-server-work-before-startup/). I am excited about the backend and the UI improvements, but you should be able to try them without wondering what else an update will break. That is the release quality we need to earn.
+
+---
+
+## Discussion
+
+_Which green check has given your team the most misleading confidence before a release?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/gradle-smaller-projects.md b/docs/website/content/blog/gradle-smaller-projects.md
new file mode 100644
index 00000000000..866d0ff3ae0
--- /dev/null
+++ b/docs/website/content/blog/gradle-smaller-projects.md
@@ -0,0 +1,182 @@
+---
+title: "Do You Prefer Gradle?"
+slug: gradle-smaller-projects
+url: /blog/gradle-smaller-projects/
+date: '2026-10-05'
+author: Shai Almog
+description: "Optional Gradle projects remove empty platform modules, support standalone backends, and use the same build engine as Maven."
+feed_html: ' Optional Gradle projects remove empty platform modules, support standalone backends, and use the same build engine as Maven.'
+series: ["release-2026-10-02"]
+---
+
+
+
+You can now choose Gradle for a Codename One project. Start with fewer files, add platform directories when you need native code, or create a standalone backend without a mobile app attached. A smaller project is easier to browse and leaves less scaffolding competing for space in an LLM's context.
+
+I like Maven XML. I know it is verbose. I also spent enough time at Sun Microsystems staring at deeply scripted, heavily patched `make` files to develop a lasting suspicion of clever build systems.
+
+Someone starts with a reasonable shortcut. Someone else needs one more condition. A few years later the build has its own undocumented programming language and nobody wants to touch it. I would rather a build system be strict and limited. Give people enough power and, with the best intentions, they build a Frankenstein build.
+
+That is a personal preference. Plenty of developers I respect love Gradle, or at least appreciate what it lets them do. This week we added [optional Gradle support](https://github.com/codenameone/CodenameOne/pull/5922) because it lets us offer something useful: a smaller Codename One project, including a standalone backend with no client scaffolding.
+
+## Start with fewer files
+
+The Maven app layout has a root POM and platform modules ready for native code. That makes the structure explicit, but a new app often has no code in most of those places.
+
+A Gradle app starts with the sources and configuration it needs. Native directories appear when you generate native interfaces. A backend subproject appears when you add a backend.
+
+For a concrete example, we converted the checked-in HelloCodenameOne sample with the current converter:
+
+| Project files | Maven sample | Converted Gradle sample |
+| --- | ---: | ---: |
+| Total files, including app sources and resources | 358 | 305 |
+| Maven POMs | 9 | 0 |
+| Gradle Kotlin configuration files | 0 | 2 |
+
+That removes **53 files, about 15% of the tree**. We counted the tracked sample before conversion and all files in the converter's new directory afterward, excluding build output and caches. This is the existing demonstration app, with its resources and Kotlin source, rather than a comparison of two different Hello World programs.
+
+The generated `settings.gradle.kts` is small enough to show in full, with its explanatory comments removed:
+
+```kotlin
+pluginManagement {
+ repositories {
+ maven("https://repo.codenameone.com/maven2")
+ gradlePluginPortal()
+ }
+}
+plugins {
+ id("com.codenameone") version "8.0-SNAPSHOT"
+}
+rootProject.name = "HelloCodenameOne"
+```
+
+The sample conversion uses the development version. Select the release containing this support when it is available. The app's own dependencies and Kotlin plugin go in `build.gradle.kts`; the framework's platform builders come from the Codename One plugin.
+
+
+```text
+MyApp/
+ settings.gradle.kts
+ gradle.properties
+ gradlew
+ gradle/wrapper/
+ codenameone_settings.properties
+ icon.png
+ src/main/java/
+ src/main/css/theme.css
+ src/main/resources/
+```
+
+Add `build.gradle.kts` when you have dependencies or build configuration of your own. Kotlin source belongs in `src/main/kotlin` when the project applies the Kotlin plugin.
+
+That smaller tree helps a human understand an unfamiliar project. It can also reduce the irrelevant files an agent sees when building its context. The file reduction is measurable; the context saved depends on which files your agent reads.
+
+## Keep the same builds when you switch
+
+We did not implement a second set of platform builders. The Gradle plugin calls the shared engine used by Maven. That includes upload staging, local builders, CSS compilation and bytecode compliance checks.
+
+{{< mermaid >}}
+flowchart TD
+ Maven[Maven plugin] --> Engine[Shared Codename One build engine]
+ Gradle[Gradle plugin] --> Engine
+ Engine --> CSS[Compile CSS and check bytecode]
+ Engine --> Local[Generate local platform projects]
+ Engine --> Upload[Stage cloud build upload]
+{{< /mermaid >}}
+
+From a generated Gradle app:
+
+```bash
+./gradlew run
+./gradlew cn1Test
+./gradlew buildJavascriptLocal
+./gradlew buildIosXcodeProject -Popen=false
+```
+
+`run` starts the simulator. `cn1Test` uses the simulator test runner. The last two commands build the JavaScript port locally and generate an Xcode project. Tasks that submit cloud builds are available too, with the same service requirements as Maven.
+
+There are limits. Running Gradle requires JDK 17 or newer and Gradle 8.5 or newer; the generated wrapper supplies Gradle. These projects target Java 17. They do not support legacy `.cn1lib` files or the old resource Designer task. The OpenAPI, gRPC and GraphQL generators and on-device debugging helpers still have Maven goals without equivalent Gradle tasks. The [workflow chapter](/developer-guide/gradle-project-workflow/) lists the supported surface.
+
+## Build a standalone Java backend
+
+In the [Initializr](/initializr/), choose **Gradle** as the build tool and **Backend only** as the project type. The server lives at the root, with its Java source and application properties. There is no client theme, simulator module or collection of empty native directories.
+
+For a generated project named `MyService`:
+
+```bash
+CN1_PROFILE=dev ./gradlew runBackend
+```
+
+That runs the development server on the JVM. Stop it before changing the backend code; this is a restart workflow, not hot reload. To build and run the native executable:
+
+```bash
+./gradlew backendPackage
+CN1_PROFILE=dev PORT=9000 ./build/MyService
+```
+
+The development profile uses the generated in-memory SQLite configuration. Without it, the starter reads its production settings and expects `DATABASE_URL`. The executable's name follows the project name.
+
+An existing Gradle app can gain a server with:
+
+```bash
+./gradlew addBackend
+CN1_PROFILE=dev ./gradlew :backend:runBackend
+./gradlew :backend:backendPackage
+```
+
+I hope people will try the backend on its own. It is still experimental, but a small independent service can reveal useful constraints without requiring a mobile application first. The [weekly overview](/blog/java-server-work-before-startup/) shows the Spring-style programming model it now supports.
+
+## Try Gradle alongside your Maven project
+
+The converter leaves the original project in place and writes a sibling project. Replace `VERSION` with the Codename One plugin release containing this feature:
+
+```bash
+mvn com.codenameone:codenameone-maven-plugin:VERSION:convert-to-gradle \
+ -Dcn1.sourceProject=/path/to/MyApp \
+ -Dcn1.outputDir=/path/to/MyApp-gradle
+```
+
+The destination must be empty or absent. The conversion carries sources, resources, CSS and platform implementations into the new layout, and raises the application's bytecode target to Java 17. A customized backend comes across; the untouched backend skeleton is optional. Legacy `.cn1lib` dependencies stop conversion with their names rather than silently disappearing.
+
+Open the converted project and run its tests before switching the team's build. Your old checkout remains available for comparison.
+
+## Find the API for the code you are writing
+
+Last week we split the Developer Guide into chapters. Before that, we rebuilt the Javadocs. A backend-only project made the next problem obvious: a client API page is the wrong answer when you are writing a server.
+
+[PR #5918](https://github.com/codenameone/CodenameOne/pull/5918) separates the [client API](/javadoc/) from the [backend API](/backend/javadoc/). The references label their audience and link shared classes to their counterpart. Backend classes belong in the backend reference; a UI implementation package does not belong there just because it exists in the repository.
+
+| What you are writing | Reference to start with |
+| --- | --- |
+| A form, component or device integration | [Client Javadocs](/javadoc/) |
+| A controller, database service or scheduled job | [Backend Javadocs](/backend/javadoc/) |
+| Shared models and mapping code | The shared class page, with its counterpart link |
+
+The distinction helps readers and code-generation tools for the same reason: it reduces the chance of choosing an API that exists in the wrong runtime. Both references are checked with `doclint`, so malformed documentation has a build-time consequence too.
+
+## Try Gradle 9 for your Android build
+
+The optional Gradle project layout and the Gradle version used inside a generated Android project are different choices. You can keep your Codename One app on Maven and still test the newer Android builder.
+
+In Settings, under **Build Hints**:
+
+```properties
+android.gradleVersion=9
+```
+
+Or in `codenameone_settings.properties`:
+
+```properties
+codename1.arg.android.gradleVersion=9
+```
+
+The current builder pairs Gradle 9.8.0 with Android Gradle Plugin 9.4.1. It adjusts the generated project for removed DSL elements and AGP's built-in Kotlin support. This selects the experimental Gradle 9 / Android Gradle Plugin 9 path from [PR #5919](https://github.com/codenameone/CodenameOne/pull/5919). It is opt-in. Much of the surrounding tooling and library configuration still assumes Gradle 8. Test your actual native dependencies and generated Android project before adopting it; a successful empty app is not the same test.
+
+I expect to keep using Maven for plenty of projects. Supporting Gradle gives teams another way into the same build machinery, and gives a small server a project tree that looks like a small server.
+
+---
+
+## Discussion
+
+_How much freedom do you want a build system to give the next person maintaining it?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/ios27-glass-from-measurements.md b/docs/website/content/blog/ios27-glass-from-measurements.md
new file mode 100644
index 00000000000..389ddabc453
--- /dev/null
+++ b/docs/website/content/blog/ios27-glass-from-measurements.md
@@ -0,0 +1,137 @@
+---
+title: "Can You Tell the Difference Between These iOS Tab Bars?"
+slug: ios27-glass-from-measurements
+url: /blog/ios27-glass-from-measurements/
+date: '2026-10-04'
+author: Shai Almog
+description: "Reconstructing iOS 27 tab motion from real touches, spring equations, color matrices and a side-by-side simulator comparison."
+feed_html: ' Reconstructing iOS 27 tab motion from real touches, spring equations, color matrices and a side-by-side simulator comparison.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Watch the two tab bars below. Tap, hold, drag across the bar, then change direction. Can you tell which one is UIKit and which one is drawn by Codename One?
+
+That is a more useful test than a still image. Your users feel the delay before a selection moves, the way the glass follows a finger and the settling motion after release. A tab bar can have the right colors and still feel wrong in your hand.
+
+[Last week's iOS 27 theme](/blog/ios-27-glass-you-can-test/) was close, but I still wasn't happy with those interactions. Getting closer meant recording UIKit's presentation layers during real touches, fitting the motion to spring equations and reconstructing the glass effects. Here is the result, followed by the measurements and formulas behind it.
+
+## Watch the same gestures twice
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*UIKit is on top and Codename One below. These committed iOS 27 simulator recordings use the same touch sequence: six taps, a held press, a tap on the selected tab, a slow drag and a flick. Each gesture occupies a 4.2-second slot aligned on the touch.*
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*The dark appearance exposes the edge, vibrancy and refraction differences more clearly. UIKit is above Codename One in both simulator recordings.*
+
+The [recording script](https://github.com/codenameone/CodenameOne/blob/master/scripts/record-ios-tabs-side-by-side.sh) and [video notes](https://github.com/codenameone/CodenameOne/blob/master/docs/videos/README.md) make the provenance inspectable. The remaining differences are part of the comparison: the lifted lens, its rounded ends and the saturation still deserve work.
+
+## Why your tab bar can look right and feel wrong
+
+Setting the selected tab in code did not produce the complete native interaction. UIKit performs that motion for genuine touches on a controller-managed bar. The probe therefore uses XCUITest taps, holds, and drags.
+
+There was another complication: UIKit did not attach a simple `CAAnimation` containing the whole trajectory. It updated layer values frame by frame. The useful record was the presentation geometry at each display refresh: position, bounds, transform, opacity and the touch timestamps that explained them.
+
+{{< mermaid >}}
+flowchart LR
+ Touch[Real XCUITest gesture] --> UIKit[Native tab controller]
+ UIKit --> Log[Per-frame presentation geometry]
+ Log --> Fit[Fit springs and retained curves]
+ Fit --> Java[Java motion model]
+ Log --> Fixture[Recorded fixtures]
+ Java --> Check[Replay and compare]
+ Fixture --> Check
+{{< /mermaid >}}
+
+Capturing an image on every frame changes the timing enough to contaminate the measurement. The probe separates geometry logging from optional frame snapshots. Snapshot runs are useful for comparing the lens at the same motion state, not for fitting its timing. Likewise, lossless screenshots over known backdrops reveal the blur; compressed video smears the very edges we need to inspect.
+
+Those constraints are documented in the [native probe](https://github.com/codenameone/CodenameOne/tree/master/scripts/fidelity-app/ios-native-ref/motion-probe). They explain why “looks close in a recording” was not enough.
+
+## Make taps, holds and drags respond differently
+
+For a fixed target, a damped spring follows this equation:
+
+
+
+Here `x` is position, `xₜ` is the target, `ω` controls the natural frequency and `ζ` the damping. Dots denote derivatives with respect to time. A critically damped spring has `zeta = 1`; lower damping allows an overshoot. The implementation uses the measured constants rather than retuning the entire animation by eye:
+
+| Channel | Model in the current source |
+| --- | --- |
+| Selection travel | `omega = 2*pi/0.4`, `zeta = 0.85` |
+| Lens lift | Critical damping, `omega = 2*pi/0.25` |
+| Platter return | Critical damping, `omega = 2*pi/0.4` |
+| Whole-bar press growth | `omega = 17.6`, `zeta = 0.59` |
+| Lens following a drag | `omega = 32`, `zeta = 0.90` |
+
+The travel stops once the remaining distance after the overshoot is below about 0.195 points. The drag and press models include a measured 20 ms touch lag. These small details are visible because your finger gives the animation a moving reference point.
+
+The current [TabGlassMotion](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/TabGlassMotion.java) and [TabGlassGesture](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/TabGlassGesture.java) contain the formulas, retained tables and stopping rules. The regeneration tool checks the closed forms against captures and rewrites the channels that remain tabulated.
+
+## Let users drag across tabs without selecting each one
+
+During a drag the lens follows the finger on its own spring, so it can lag behind. On release, UIKit selects the tab under the finger, not the one nearest the lagging lens. The lens then settles toward that tab from its current position and velocity.
+
+Resetting velocity at that handoff creates a visible interruption. Snapping to the nearest lens position after a fast flick creates another discontinuity. A press on the already selected tab must also lift and pulse without inventing travel to another tab. A held press has to keep its lifted state until release rather than play a fixed-duration tap and finish underneath your finger.
+
+The release adds a small wobble. Our model uses a common starting point for it even though the captures show slightly different onset times across gesture types. That approximation is one reason to keep the full gesture suite alongside the short demo.
+
+## Keep icons legible as the backdrop changes
+
+A vibrant tab icon is not simply painted with an alpha color. Its result depends on the glass behind it. The probe reads UIKit's color matrices across tint sweeps, and `VibrancyMatrix` reconstructs the transform.
+
+For a non-gray dark tint vector `t`, the measured form is:
+
+```text
+e = 0.5 * min(t) / max(t)
+M = e*I + (0.5 - e) * (ones * transpose(t)) / dot(t,t)
+offset = t
+output = M * backdrop + offset
+```
+
+`I` is the identity matrix and `ones` is a column of three ones. Gray tints have their own formula, so this expression is not a universal branch to paste over the implementation. Light appearance uses a different form. The [vibrancy source](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/plaf/VibrancyMatrix.java) and recorded fixture hold those cases together.
+
+The selection platter also transforms the bar's existing glass. `Graphics.colorMatrixRegion` applies that operation within a shape and optional mask. The lifted lens needs a separate operation: refraction around a circular bevel, color dispersion, an outline, rim light and shadow. `glassLensRegion` supplies that rendering path.
+
+This is why adjusting the opacity of a rounded rectangle could only take us so far. The effect changes the content underneath it.
+
+## Keep the glass animation on the GPU
+
+A more accurate motion model is wasted if the renderer misses the frames that distinguish it. The iOS bar glass now runs on the GPU instead of passing through a CPU blur with GPU synchronization around it. Mutable images reuse their stencil texture. The tab animation avoids asking for a second whole-component repaint, and the lens scratch texture is released after use.
+
+The portable color-matrix operation reaches the JavaScript port too. The browser lens still lacks the full optics implementation. A shared API does not mean every rendering backend implements every effect today.
+
+## Choose the appearance, then test your screen
+
+In the Settings app's **Build Hints**, select:
+
+```properties
+ios.themeMode=modern
+ios.themeGeneration=27
+```
+
+For the cloud toolchain, `ios.xcode_version=27` is a separate setting. In `codenameone_settings.properties`, prefix build-hint keys with `codename1.arg.`. A local Xcode build uses the Xcode installation selected on your Mac.
+
+Codename One draws these controls itself. The theme and its motion ship with the app, so adopting this appearance remains your decision. That control also gives us the responsibility to measure the behavior we reproduce.
+
+Try the animation over a photograph, a scrolling list and a plain dark background. Hold it. Drag past the middle and release. The [implementation in PR #5906](https://github.com/codenameone/CodenameOne/pull/5906) and the fixtures behind it make those interactions repeatable instead of leaving fidelity to memory.
+
+---
+
+## Discussion
+
+_Which gesture exposes an animation that looked right in a screenshot?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/java-server-work-before-startup.md b/docs/website/content/blog/java-server-work-before-startup.md
new file mode 100644
index 00000000000..fe50dc6fb2d
--- /dev/null
+++ b/docs/website/content/blog/java-server-work-before-startup.md
@@ -0,0 +1,429 @@
+---
+title: "A Smaller, Faster Java Server with a Spring-Style API"
+slug: java-server-work-before-startup
+url: /blog/java-server-work-before-startup/
+date: '2026-10-02'
+author: Shai Almog
+description: "Build a smaller native Java service with Spring-style transactions and dependency injection. Inspect the generated code and compare local Linux startup, memory, throughput, binary size and build time."
+feed_html: ' Build a smaller native Java service with Spring-style transactions and dependency injection. Inspect the generated code and compare local Linux startup, memory, throughput, binary size and build time.'
+series: ["release-2026-10-02"]
+---
+
+
+
+What do you pay for Spring and Java's dynamic architecture? Can you deliver the same API without the same runtime cost?
+
+For a small service, you might want dependency injection, transactions and scheduled jobs without a long startup or a large deployment. That is the case our native Java backend is trying to make. Write a controller and a service, compile their wiring into the application, then deploy a native executable.
+
+In the two-core Linux HTTP test below, the CN1 executable occupies `5.17 MiB` and reaches its first verified response in `14.8 ms`. The same two endpoints in Spring/GraalVM occupy `88.31 MiB` and respond in `43.6 ms`. That is the sort of difference worth investigating for a small service.
+
+This week's Spring-style API adds the parts that make that approach useful beyond a greeting endpoint: transaction propagation, scoped beans, background tasks, sessions, metrics and MCP tools. ParparVM supplies the native runtime, including virtual threads that can park while a handler waits for PostgreSQL, MySQL or another HTTP service.
+
+**This is a Spring-style API, not a drop-in Spring implementation.** Its annotations live in `com.codename1.backend.annotations`. Spring itself supports AOT processing and GraalVM Native Image. Our proposition is a smaller supported surface with direct generated calls, a native runtime shared with our app framework, and code you can inspect when you want to know what an annotation costs.
+
+The backend is still a work in progress. It sits on ParparVM, the runtime behind our native iOS apps, and is maturing rapidly. The local measurements below show where it earns the “smaller, faster” description. They also define the narrow workload being compared.
+
+## Coming This Week
+
+Today's article covers the backend API, generated code and local server comparison. The follow-ups explore what you can do with the rest of the release:
+
+- **Saturday, October 3:** {{< post-link path="/blog/parparvm-four-byte-header" text="Honey, I Shrunk Java" >}}. How object headers, compiler optimizations and garbage collection affect the memory and CPU your application needs.
+- **Sunday, October 4:** {{< post-link path="/blog/ios27-glass-from-measurements" text="Can You Tell the Difference Between These iOS Tab Bars?" >}}. Compare the videos, then see how measured motion and glass formulas make your UI feel closer to UIKit.
+- **Monday, October 5:** {{< post-link path="/blog/gradle-smaller-projects" text="Do You Prefer Gradle?" >}}. Start with fewer files, build a standalone backend, find the right Javadocs, and try the separate Android Gradle 9 option.
+- **Tuesday, October 6:** {{< post-link path="/blog/native-backend-observability" text="Connect Your App to Your Enterprise Traces" >}}. Connect your client app and native backend to traces across your enterprise services, with metrics and MCP alongside them.
+- **Wednesday, October 7:** {{< post-link path="/blog/browser-desktop-theme" text="Do You Want Your Web App to Feel Like a Native App?" >}}. Use desktop themes and visible menus in the browser. The Certificate Wizard gets the same theme families.
+- **Thursday, October 8:** {{< post-link path="/blog/friday-release-better-gates" text="Don't Order Fish on Monday. Don't Release on Friday" >}}. Catch private API imports before submission, and what a difficult Friday release taught us about gaps in testing.
+
+## Compare startup, memory, throughput and build time
+
+The measurements use CN1 revision [`60c4f310`](https://github.com/codenameone/CodenameOne/tree/60c4f310bddcfc51e5acc75c63a57c43c73430d3). For the comparison, we ran two small HTTP handlers on the Linux deployment target: a 13-byte plaintext response and a JSON object containing one `message` field. The CN1 executable uses the repository's lower-level `Bench` handler. Spring Boot 4.1.1 uses Spring MVC and embedded Tomcat, running either on Temurin JDK 25 or as a GraalVM 25 native executable.
+
+**This compares the selected HTTP stacks, not equivalent framework features.** The CN1 handler does not exercise the annotation-generated application shown below. There is no database, TLS, authentication, or telemetry in either application. Both JSON handlers create a map per request; CN1 also allocates a fresh response object.
+
+The host is an Apple M4 Max with 16 logical CPUs and `64 GiB` RAM. The local Linux ARM64 VM has four virtual CPUs and `8 GiB`. Linux CPU affinity restricts the server to 1, 2, or 4 CPUs. At 1 and 2, the load generator runs on the remaining CPUs; at 4, it shares them with the server. These are actual scheduling restrictions, not just a reported processor count.
+
+### Start quickly and ship a smaller executable
+
+The two-core configuration gives the server and load generator separate CPUs. Here are medians from three fresh processes, with the startup range in parentheses:
+
+| Application | First response, ms: median (range), lower is better | Native executable, MiB, lower is better |
+| --- | ---: | ---: |
+| CN1 native | 14.8 (5.3-15.1) | 5.17 |
+| Spring Boot / JDK 25 | 1,501.1 (1,407.6-1,617.8) | N/A |
+| Spring Boot / GraalVM 25 | 43.6 (32.5-45.6) | 88.31 |
+
+[](/blog/native-http-charts/startup.png)
+
+Startup includes spawning the process and receiving a verified HTTP response. File system caches are left warm; this is not a cold-machine or serverless measurement. The polling loop and `taskset` launcher also contribute to the short native times. The JVM run uses its default runtime settings without an AOT cache.
+
+[](/blog/native-http-charts/binary-size.png)
+
+The CN1 executable is `5.17 MiB`, compared with `88.31 MiB` for this Spring native build. These are uncompressed executable files from the default build outputs. Both files were unchanged by an additional pass that strips symbols. Both builds use shared system libraries, which are excluded here. This is not a container-size or complete-deployment comparison. The JVM column is N/A because its JAR is not a standalone native executable.
+
+### Leave more memory for the work your service does
+
+A server's memory use changes after it starts accepting traffic. We recorded all three stages using the same windows for each runtime:
+
+| Application, 2 allowed CPUs | Idle before load, MiB | Peak through load, MiB | Idle after load, MiB |
+| --- | ---: | ---: | ---: |
+| CN1 native | 10.0 | 57.8 | 29.8 |
+| Spring Boot / JDK 25 | 163.0 | 282.2 | 282.3 |
+| Spring Boot / GraalVM 25 | 78.1 | 117.0 | 79.6 |
+
+[](/blog/native-http-charts/memory.png)
+
+*Lower is better in all three memory columns. Idle before load is sampled three seconds after the first verified response. Peak is the kernel's resident-memory high-water mark through startup and both routes. Idle after load is sampled five seconds after traffic ends, without forcing collection. Each table entry is the median of the three process measurements.*
+
+CN1 uses less resident memory in both the idle and loaded measurements here. Four-byte object metadata is only one part of that cost. RSS also includes code, stacks, allocator pages and library state; it is not the live Java heap. This Linux build uses native virtual threads, so its connection costs differ from a platform-thread pool.
+
+### Serve requests with 1, 2 or 4 CPUs
+
+| Allowed server CPUs | Application | Plaintext requests/s | JSON requests/s |
+| --- | --- | ---: | ---: |
+| 1 | CN1 native | 164,542 | 138,555 |
+| 1 | Spring Boot / JDK 25 | 34,721 | 64,068 |
+| 1 | Spring Boot / GraalVM 25 | 40,286 | 39,167 |
+| 2 | CN1 native | 287,997 | 261,121 |
+| 2 | Spring Boot / JDK 25 | 69,953 | 70,491 |
+| 2 | Spring Boot / GraalVM 25 | 51,729 | 49,000 |
+| 4 | CN1 native | 245,608 | 251,435 |
+| 4 | Spring Boot / JDK 25 | 116,491 | 110,530 |
+| 4 | Spring Boot / GraalVM 25 | 80,053 | 61,873 |
+
+[](/blog/native-http-charts/throughput.png)
+
+*Higher is better. Points are medians; whiskers show the three-run range. Each route has ten seconds of warmup and ten seconds of measurement, using two `wrk` threads and 32 connections. Plaintext precedes JSON. Four-core points include load-generator contention, so this is not a clean four-core scaling curve.*
+
+### Does HotSpot catch up after warmup?
+
+CN1 still leads after a minute of warmup per endpoint: **3.9 times the plaintext throughput and 3.4 times the JSON throughput** of Spring/JDK 25 in the matched two-core follow-up. Both servers received the same longer warmup, followed by three consecutive ten-second measurement windows for each route.
+
+| Application, 2 allowed CPUs | Plaintext requests/s | JSON requests/s |
+| --- | ---: | ---: |
+| CN1 native, 60 s warmup per route | 296,928 | 250,268 |
+| Spring Boot / JDK 25, 60 s warmup per route | 75,721 | 73,613 |
+
+[](/blog/native-http-charts/warmed-throughput.png)
+
+*Higher is better. These are medians of three windows within one fresh process per runtime, separate from the three-process matrix above. The server uses CPUs 0 and 1; `wrk` uses CPUs 2 and 3, with 32 connections. Both routes completed without socket or non-2xx errors.*
+
+We checked HotSpot's compiled-method list during warmup: Spring's request dispatcher and handler adapter had reached tier-4 compilation. The snapshot is included in the reproduction bundle. The extra warmup does not close the gap for these two handlers. More complex application code, dependencies and different concurrency levels can change that comparison.
+
+The matrix rotates runtime order and reverses CPU order in its middle round. Every response body is checked before load; any socket or non-2xx error during warmup or measurement rejects the run. All 27 process runs completed without those errors. Keep-alive request limits are raised or disabled on both servers; other runtime settings use their defaults.
+
+### How long do you wait for a build?
+
+Native compilation moves work out of startup and into the build. You do not need to pay that cost after every edit: CN1's debug/development mode runs on the JVM, while the native build produces the deployment executable.
+
+| Build | Median elapsed, seconds | Three-run range, seconds |
+| --- | ---: | ---: |
+| Spring Boot / JDK 25 | 2.07 | 1.54-2.57 |
+| CN1 debug / JVM | 1.67 | 1.57-2.49 |
+| CN1 native | 95.34 | 75.43-107.08 |
+| Spring Boot / GraalVM 25 | 200.89 | 174.80-214.39 |
+
+[](/blog/native-http-charts/build-time.png)
+
+*Lower is better. Three builds per configuration, with runtime order rotated, on the same four-vCPU, `8 GiB` Linux VM. Application outputs are rebuilt each time; dependencies and toolchains are cached. Downloads, tests and server startup are excluded.*
+
+For this example, the CN1 native build takes **53% less elapsed time** than Spring/GraalVM. The JVM builds take seconds. That keeps the edit-and-debug loop short while letting you check the native artifact before deployment.
+
+The CN1 development measurement compiles the repository's `Bench` handler, JavaSE backend runtime and shared sources with JDK 25. The native path compiles Java with JDK 8, translates it, then compiles and links the generated C with Clang at `-O3`; the translator and Java API dependencies are prebuilt. Spring uses Maven `clean package` on JDK 25; its native build adds Spring AOT processing and GraalVM `native:compile`. These are build-path timings for the HTTP examples, including their different build tools, rather than isolated `javac` or incremental-build timings.
+
+The [reproduction bundle](/blog/native-http-comparison.zip) includes sources, commands, artifact hashes, every raw sample, the matched longer-warmup comparison, clean-output build timings, and the generated Java example. The results make a small native backend worth trying for services with these constraints. Measure your own handlers and dependencies before using them to choose deployment capacity.
+
+## Start your service with less runtime setup
+
+Here is a complete controller for a backend module:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.GetMapping;
+import com.codename1.backend.annotations.RestController;
+
+@RestController
+public class GreetingApi {
+ @GetMapping("/hello")
+ public String hello() {
+ return "Hello, World!";
+ }
+}
+```
+
+After `javac` compiles your sources, the build reads the annotations and generates Java classes for routing, dependency injection and method instrumentation. ParparVM translates the resulting bytecode to C, then the native compiler builds the executable.
+
+[](/developer-guide/img/backend-build-pipeline.svg)
+
+*From the current Backend guide. The generated classes are ordinary input to the translator and its dead-code analysis.*
+
+A generated `Router` holds the route as bytes and binds parameters according to their declared types. `BackendWiring` creates beans in dependency order. Missing dependencies, ambiguous candidates, constructor cycles and duplicate routes fail the build with the relevant class or injection point.
+
+Here is an excerpt of the wiring generated for this controller and the `Notes` service in the next section. Only line wrapping and the surrounding method have been omitted:
+
+```java
+b_greetingApi = new example.GreetingApi();
+b_notes = new example.Notes(
+ com.codename1.backend.Backend.requireDataSource(
+ dataSource, "constructor parameter 1 of example.Notes"));
+```
+
+There is no runtime search for a `Notes` constructor or a matching database bean. The call is in the generated program. With more dependencies, the build orders the constructor calls and emits field or setter injection afterward. A private `@Autowired` field gets a generated setter so the assignment can still be a direct call.
+
+This gives you a useful debugging option: follow the call into the generated code and see exactly what it constructs. It also lets the native linker remove unreferenced classes. You exchange some of Spring's runtime flexibility for a build that can resolve more of the application before deployment.
+
+## Keep your transaction when you call another method
+
+If you use Spring's usual proxy-based transactions, a call through `this` bypasses the proxy. That can make a refactor change transactional behavior even though the annotation is still on the method. Spring documents both the limitation and its bytecode-weaving alternative in the [proxying guide](https://docs.spring.io/spring-framework/reference/core/aop/proxying.html).
+
+Our build rewrites the annotated method itself. `@Transactional`, `@Async`, `@Timed` and `@Counted` therefore apply when another method on the same object calls it. They also apply to private methods and project classes you construct with `new`.
+
+For example, this service writes a note and an audit row in one transaction. Assume migrations have created `note(body)` and `audit(message)` in the configured database:
+
+```java
+package example;
+
+import com.codename1.backend.DataSource;
+import com.codename1.backend.annotations.Component;
+import com.codename1.backend.annotations.Transactional;
+import java.io.IOException;
+
+@Component
+public class Notes {
+ private final DataSource db;
+
+ public Notes(DataSource db) {
+ this.db = db;
+ }
+
+ @Transactional(rollbackFor = IOException.class)
+ public void add(String body) throws IOException {
+ db.execute("INSERT INTO note (body) VALUES (?)", new Object[] {body});
+ db.execute("INSERT INTO audit (message) VALUES (?)",
+ new Object[] {"note created"});
+ }
+}
+```
+
+What does the annotation become? We ran this class through the current processor. It moves the original body into `add$cn1body_Notes` and makes `add` delegate to this generated helper. Package qualifiers are shortened below and line breaks added for readability; the control flow and rollback expression are the generated output:
+
+```java
+static void add(example.Notes self, java.lang.String a0) throws Throwable {
+ Object cn1Tx = BackendAccess.get().begin(BackendAccess.REQUIRED, false, -1);
+ try {
+ self.add$cn1body_Notes(a0);
+ } catch (Throwable cn1Error) {
+ BackendAccess.get().afterThrow(cn1Tx,
+ cn1Error instanceof java.io.IOException ? true :
+ (cn1Error instanceof java.lang.RuntimeException
+ || cn1Error instanceof java.lang.Error
+ || cn1Error instanceof DataAccessException));
+ throw cn1Error;
+ }
+ BackendAccess.get().commit(cn1Tx);
+}
+```
+
+`BackendAccess` is an internal bridge used by generated code. Your service uses `@Transactional`; it does not call that bridge itself. The body runs inside a transaction boundary regardless of how you reached `add`. The generated helper asks the transaction manager to complete or roll back the appropriate boundary, then propagates a failure. There is no runtime annotation lookup or proxy dispatch for this method. The [processor source](https://github.com/codenameone/CodenameOne/blob/3d2db4eee774cf7d0d0a18fc3100d005ce108897/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/processors/BackendSources.java) and [bytecode weaver](https://github.com/codenameone/CodenameOne/blob/3d2db4eee774cf7d0d0a18fc3100d005ce108897/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/processors/BackendWeaver.java) show both halves.
+
+The database connection is borrowed lazily, at the first database operation. The method can return without touching the pool if it never accesses the database. `DataSource`, generated DAOs and managed ORM sessions join the transaction associated with the executing thread.
+
+[](/developer-guide/img/backend-transaction-propagation.svg)
+
+You can choose all seven propagation modes: `REQUIRED`, `REQUIRES_NEW`, `NESTED`, `SUPPORTS`, `MANDATORY`, `NOT_SUPPORTED` and `NEVER`. The important choices are what you want to happen when a transaction exists, and whether an inner failure should undo the outer work. `REQUIRES_NEW` needs another connection; `NESTED` uses a savepoint on the current one.
+
+Read-only declarations, timeouts and explicit rollback rules are supported. Isolation-level selection is not. An asynchronous task does not inherit its caller's transaction, and a database transaction cannot undo an email or an HTTP request. The [data chapter](/developer-guide/backend-data/) spells out these boundaries, including what happens when code touches more than one connection pool.
+
+## Handle more waiting requests without a thread per connection
+
+If your handler spends most of its time waiting for another server, an OS thread per connection is expensive. You want straightforward blocking code without making each wait occupy a host thread.
+
+On the Linux native HTTP path, each connection has a ParparVM virtual thread: a stack retained for the life of that connection. Host threads run those stacks. A host owns its connections and their `epoll` registrations; a virtual thread stays with that host. When the handler needs bytes that have not arrived, the runtime parks its stack and lets the host run another connection.
+
+[](/developer-guide/img/backend-architecture.svg)
+
+That applies beyond the incoming socket. PostgreSQL and MySQL queries use the same parking mechanism. Outbound HTTP, including its TLS handshake, can park too. Your service can wait for a query in ordinary sequential Java while other connections continue on the same host.
+
+{{< mermaid >}}
+sequenceDiagram
+ participant A as Request A
+ participant H as Host thread
+ participant DB as Database socket
+ participant B as Request B
+ H->>A: Resume handler
+ A->>DB: Send query
+ A-->>H: Park until socket is ready
+ H->>B: Run another handler
+ B-->>H: Finish response or park
+ DB-->>H: epoll reports readable socket
+ H->>A: Resume at the waiting call
+{{< /mermaid >}}
+
+Background tasks now participate in this model too. A virtual task has no incoming connection descriptor, so the host uses a wake pipe to notice newly submitted work. `Future.get()` on a virtual thread yields cooperatively while waiting for the task. Blocking the host there could otherwise stall the very task whose result the handler needs.
+
+This work also fixed a subtle scheduler failure: each yield site must report whether it is runnable or waiting for I/O. A stale reason could leave a handler stuck after `yieldNow()` or send an I/O wait back through the runnable path after garbage-collector backpressure. A virtual-thread API is only useful when those transitions remain correct under load.
+
+You still need to choose the right executor for your work:
+
+| Your operation | Native virtual-thread behavior | Practical choice |
+| --- | --- | --- |
+| Wait for PostgreSQL, MySQL or outbound HTTP | Parks at supported socket waits | Virtual threads suit this work |
+| Wait on an asynchronous task's `Future` | Yields cooperatively | A virtual handler can await virtual work |
+| SQLite, file access, DNS resolution or `Object.wait()` | Can block the host thread | Put blocking local work on a platform executor |
+| Incoming TLS server connection | Uses the platform-thread pool | Account for pool capacity |
+| JVM development run | Uses platform threads, including `VIRTUAL` tasks | Test native concurrency before deployment |
+
+These are ParparVM's virtual threads, not the JDK implementation. `ThreadKind.PLATFORM` remains the default for `@Async` and `@Scheduled`; `VIRTUAL` requests the native facility where available, and `AUTO` selects it when the server has virtual hosts. The [scheduling chapter](/developer-guide/backend-scheduling/) documents fallback behavior and named executors.
+
+## Schedule work without accidental duplicate runs
+
+A scheduled method runs outside the request thread. Use a fixed rate when you want starts at regular intervals, or a fixed delay when you want a pause after the previous run finishes. The distinction becomes visible as soon as the job takes longer than expected:
+
+[](/developer-guide/img/backend-schedule-timelines.svg)
+
+One job does not overlap itself within a process. If a fixed-rate job is still running at its next start, that start is skipped. The build validates the method signature and six-field cron expressions; configuration can supply the actual schedule.
+
+When you deploy several server instances, each instance has a scheduler. A database lock lets them coordinate one job across replicas. For example, `@Scheduled(fixedDelay = 60000, lock = "purge")` requests a shared lock. The lease must exceed the job's maximum runtime, since expiry permits another instance to claim it. You can inspect job state and skipped runs through the management endpoints.
+
+## Keep configuration and state explicit as your service grows
+
+The Spring-style surface extends beyond the three annotations in a demo:
+
+| What you need | API and behavior |
+| --- | --- |
+| Select an implementation | `@Primary` and `@Qualifier` resolve competing dependencies |
+| Bind deployment settings | `@Value` and `@ConfigurationProperties` bind configuration |
+| Enable an environment-specific bean | `@Profile` and `@ConditionalOnProperty` control activation |
+| Construct a library object | A `@Bean` factory supplies it explicitly |
+| Keep state for one request or session | `@Scope("request")` and `@Scope("session")` locate the current instance through generated stand-ins |
+| Initialize and shut down resources | `@PostConstruct` and `@PreDestroy` hooks participate in lifecycle management |
+| Measure or manage a service method | `@Timed`, `@Counted`, `@ManagedResource` and related annotations generate adapters |
+
+The build catches unresolved wiring, but runtime configuration can still deactivate a required bean or omit a necessary value. Request, session and lazy stand-ins need a non-final class and an accessible no-argument constructor. That constructor runs for the stand-in too. The [beans chapter](/developer-guide/backend-beans/) explains the supported combinations and their restrictions.
+
+Sessions use an in-memory or database store. They are created on demand, so an API that never asks for a session does not set a session cookie. Rotate the identifier at sign-in with `changeSessionId()`, and use the database store when multiple instances need to share session state. Session-scoped destruction on expiry remains a documented limitation.
+
+[](/developer-guide/img/backend-session-lifecycle.svg)
+
+There is no general `ApplicationContext` lookup, and an arbitrary JAR on the classpath does not become a compatible Spring bean library. Native backend sources currently use Java 8 language level against the supported runtime library. Packaged deployment targets Linux. Those boundaries help you decide whether a small service fits this backend before attempting a migration.
+
+## Keep your service visible across your enterprise
+
+An order can cross a client app, your native backend and several existing services. The backend can continue the incoming trace and propagate it on outbound HTTP calls so your operations team can follow that work in its existing observability system. Optional OpenTelemetry tracing and metrics are compiled into the executable, alongside management endpoints for health, jobs and application resources.
+
+The generated server has a defined request chain. Its own endpoints run before application routes, and static files come last. A wrapper handles request scope, session persistence and request metrics:
+
+[](/developer-guide/img/backend-request-lifecycle.svg)
+
+MCP gives your development tools a way to inspect the running service. An agent can list routes and beans, call an endpoint, inspect recent requests, and query database state through the development tools. You can publish application tools with `@McpTool`; the build generates their argument schemas and direct dispatch.
+
+Development tools are excluded from packaged servers by default. A production MCP endpoint requires a token. Tuesday's article connects the client and backend to an enterprise trace, then covers metrics and the MCP development workflow.
+
+To try the backend, start with the [backend guide](/developer-guide/backend/) and a small endpoint, then add a database operation and verify its rollback behavior. The implementation behind [PR #5908](https://github.com/codenameone/CodenameOne/pull/5908) is the basis for this week's expanded API.
+
+---
+
+## More This Week
+
+That is the backend story. The rest of the release reaches your app's UI, project structure and submission process. Here is a closer look at each upcoming post, plus a small maps improvement.
+
+### How your Java server uses less RAM
+
+**Saturday: {{< post-link path="/blog/parparvm-four-byte-header" text="Honey, I Shrunk Java" >}}**
+
+The server comparison above puts CN1's peak RSS at **`57.8 MiB`**, against **`117.0 MiB`** for Spring/GraalVM. Saturday explains the runtime work behind that smaller footprint: four-byte object headers, tighter fields, fewer temporary objects and changes to garbage collection. We will also look at the compiler translating itself faster than JDK 25, and explain how ParparVM's layout differs from HotSpot's compact headers and Leyden's AOT work. Headers are part of the saving; the whole server measurement includes code, stacks and libraries too.
+
+### Can your users spot the custom-rendered tab bar?
+
+**Sunday: {{< post-link path="/blog/ios27-glass-from-measurements" text="Can You Tell the Difference Between These iOS Tab Bars?" >}}**
+
+[Last week's iOS 27 theme](/blog/ios-27-glass-you-can-test/) still had motion I wasn't happy with. This comparison shows the refinement under taps, holds, and drags. Watch the original video; the small changes in timing and glass detail are the point.
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*UIKit is above Codename One in this side-by-side simulator recording.*
+
+Sunday's post follows the reverse engineering from frame measurements to spring equations, vibrancy and lens rendering. You can judge the remaining differences and choose when to adopt the theme in your app.
+
+### Choose Gradle and start with fewer files
+
+**Monday: {{< post-link path="/blog/gradle-smaller-projects" text="Do You Prefer Gradle?" >}}**
+
+You can now start a smaller Gradle project and add platform directories when needed. A standalone backend no longer requires a client project alongside it. That makes the tree easier to navigate and leaves less boilerplate in an LLM's context. I still prefer Maven XML, for reasons involving the `make` files I lived with at Sun, but your preference should not block either project shape.
+
+
+We converted the repository's HelloCodenameOne sample: **358 files became 305**, and **nine POMs became two Gradle Kotlin files**. That is 53 fewer files around the same application. The count includes sources and resources, excludes generated build output, and comes from the actual converter.
+
+The generated `settings.gradle.kts` selects the build plugin:
+
+```kotlin
+plugins {
+ id("com.codenameone") version "8.0-SNAPSHOT"
+}
+rootProject.name = "HelloCodenameOne"
+```
+
+This is an excerpt; the generated file also configures plugin repositories. Use the release version containing Gradle support when it is published. Monday shows the full setup and conversion commands.
+
+The new [backend Javadocs](/backend/javadoc/) also separate server APIs from the [client reference](/javadoc/), with shared classes identified between them. Monday covers that split and the separate, experimental Gradle 9 Android build option. Choosing Gradle for your project and changing the Android builder's Gradle version are independent choices.
+
+### Bring your app into your enterprise traces
+
+**Tuesday: {{< post-link path="/blog/native-backend-observability" text="Connect Your App to Your Enterprise Traces" >}}**
+
+Your mobile or web app can be the start of a trace that crosses a native CN1 backend, existing Java services and a database. The client and server propagate the same trace context, so compiling the backend to native code need not leave a gap in your enterprise observability. You can use your existing OTel collector and tracing system, with collector credentials kept on the server.
+
+{{< mermaid >}}
+flowchart LR
+ App[CN1 client app] -->|traceparent| Native[CN1 native backend]
+ Native -->|traceparent| Java[Existing Java service]
+ Java --> DB[(Database)]
+ App -. app spans via relay .-> Collector[Enterprise OTel collector]
+ Native -. spans and metrics .-> Collector
+ Java -. service telemetry .-> Collector
+{{< /mermaid >}}
+
+Tuesday explains the setup, sampling and metric labels that keep telemetry manageable as traffic grows, plus MCP tools for checking the service during development. Downstream services must participate in trace propagation too.
+
+### Make your browser app feel like a native desktop app
+
+**Wednesday: {{< post-link path="/blog/browser-desktop-theme" text="Do You Want Your Web App to Feel Like a Native App?" >}}**
+
+Your web app can now use native desktop OS styling: macOS (Aqua), Windows (Fluent) or Linux (Adwaita). An optional HTML title and menu bar puts commands above the application. Additional OS windows remain unsupported in the JavaScript port because of browser popup restrictions; that does not exclude Windows browsers. The Certificate Wizard adopts the same desktop theme families, continuing last week's Settings work.
+
+[](/blog/desktop-theme-collage.jpg)
+
+*The Settings app shows the three desktop theme families now available in the JavaScript port.*
+
+### Read street names along the road
+
+There is a smaller maps improvement too: names now follow the road geometry, with curved glyph placement on bends and upright text along straighter sections. Labels remain above route overlays, so the route does not hide the street you need to follow.
+
+
+
+*From the Maps guide. The renderer rejects placements that bend too sharply or collide with other labels.*
+
+This is part of the continuing vector-map work in [PR #5902](https://github.com/codenameone/CodenameOne/pull/5902). The [Maps guide](/developer-guide/maps/) covers the renderer and deeper zooming without stretching raster tiles.
+
+### Your release also has to survive submission
+
+**Thursday: {{< post-link path="/blog/friday-release-better-gates" text="Don't Order Fish on Monday. Don't Release on Friday" >}}**
+
+A working simulator or device build can still import an API that Apple rejects at submission. In this case, the unwanted imports appeared only when particular optional APIs were enabled, so most apps and our usual test configuration missed them. The new check looks for imported SDK symbols without public declarations, exercises optional feature combinations and inspects a linked Release device app. It catches a class of mistake that another happy-path test would miss.
+
+This was a rough week of regressions around the optional Xcode 27 path, push, and windows. Some overlapped, so we thought we had fixed a bug only to discover its symptoms had moved. Thursday's post explains one of those failures, why we release on Friday despite the obvious cost to our weekends, and how better gates can protect your release from ours. The Apple check has a defined scope; it cannot guarantee App Store acceptance.
+
+There is a lot to try this week. There is also work to do on the reliability of getting it into your hands. I would like you to spend the next release testing something useful in your app, rather than helping us untangle a regression. That is why the gate work matters as much as the new features.
+
+---
+
+## Discussion
+
+_What would you need to see before trying a smaller native Java backend for one of your services?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/native-backend-observability.md b/docs/website/content/blog/native-backend-observability.md
new file mode 100644
index 00000000000..d6aedc6db06
--- /dev/null
+++ b/docs/website/content/blog/native-backend-observability.md
@@ -0,0 +1,210 @@
+---
+title: "Connect Your App to Your Enterprise Traces"
+slug: native-backend-observability
+url: /blog/native-backend-observability/
+date: '2026-10-06'
+author: Shai Almog
+description: "Connect your client app and native Java backend to distributed enterprise traces, export metrics through OpenTelemetry, and keep collector credentials on the server."
+feed_html: ' Connect your client app and native Java backend to distributed enterprise traces, export metrics through OpenTelemetry, and keep collector credentials on the server.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Your customer taps “Place order.” The request crosses your app, an API gateway, a native backend, a payment service and a database. Your operations team needs to see that path in the same tracing system it uses for the rest of the company. Neither the client app nor a compiled Java server should disappear from that picture.
+
+I wrote a book on debugging, so I am probably more opinionated about this than most people: in 2026, production diagnosis should not depend on somebody searching a pile of logs with `grep` and guessing which lines belong together.
+
+Logs still matter. At enterprise scale, though, you need to connect work across machines, teams and runtimes, then see whether a failure is isolated or spreading. On a JVM, Java agents can instrument much of that work for us. Once our backend is translated to C and compiled into a native executable, the usual JVM instrumentation hook is gone.
+
+We have to carry that visibility into the binary. [OpenTelemetry support](/blog/follow-a-tap-with-opentelemetry/) started that work last week. The [expanded backend API](https://github.com/codenameone/CodenameOne/pull/5908) adds metrics and management alongside it. This article follows what happens after you turn them on.
+
+## Follow an operation across your systems
+
+Observability is the ability to understand a system's internal behavior from the evidence it emits. OpenTelemetry, usually shortened to OTel, defines APIs, data conventions and transport for producing that evidence. It is not itself the screen where you investigate an incident; a collector and an observability backend handle that part. The [OTel primer](https://opentelemetry.io/docs/concepts/observability-primer/) provides the broader model.
+
+| Question | Useful evidence |
+| --- | --- |
+| Why did this request take two seconds? | A trace connecting its operations |
+| Is database waiting increasing across the service? | Metrics over time |
+| What did the application decide at the failure? | Logs and events with context |
+
+A span records one timed operation. Related spans form a trace. Metrics aggregate behavior across operations: a count, a current value or a distribution such as request duration. Neither replaces the other. A single trace can explain a slow query without telling you how often it occurs.
+
+Our integration exports traces and metrics. It does not turn every application log into an OTLP log record.
+
+## Add tracing to your native executable
+
+Put this in the backend's `application.properties` before building:
+
+```properties
+cn1.otel.enabled=true
+```
+
+Or use the backend's `@OpenTelemetry` annotation. The generator installs the tracer, making its implementation reachable to the translator. Without that build-time opt-in, the unused tracing code can be left out. Setting an environment variable after deploying a binary that omitted the tracer cannot add it back.
+
+Once enabled, the runtime records an incoming request span named for its route template. A `Web` call creates a client span and propagates W3C trace headers. A database statement creates another client span. Incoming `traceparent` connects the request to its caller.
+
+{{< mermaid >}}
+sequenceDiagram
+ participant App as CN1 client app
+ participant Native as CN1 native backend
+ participant Service as Existing enterprise service
+ participant DB as Database
+ participant Collector as Enterprise OTel collector
+ App->>Native: Order request + traceparent
+ Native->>Service: HTTP call + traceparent
+ Service->>DB: SQL span under the same trace
+ DB-->>Service: Result
+ Service-->>Native: Result
+ Native-->>App: Response
+ App->>Native: Batched client spans via relay
+ Native->>Collector: Client spans + server spans + metrics
+ Service->>Collector: Existing service telemetry
+{{< /mermaid >}}
+
+The native backend propagates context on outbound `Web` calls. Each receiving service must accept and continue that context. OTel-compatible instrumentation lets those services participate regardless of their implementation language.
+
+## Include the client, not just the servers
+
+The client annotation belongs on your app's main class:
+
+```java
+import com.codename1.annotations.OpenTelemetry;
+import com.codename1.system.Lifecycle;
+
+@OpenTelemetry(
+ relay = "https://api.example.com",
+ serviceName = "orders-app",
+ sampleRatio = 0.2,
+ requireAnalyticsConsent = true)
+public class OrdersApp extends Lifecycle {
+}
+```
+
+Replace the URL with your backend. Enable its relay as shown below, and wire the app's analytics-consent flow before collecting telemetry. The client instruments supported app operations and `ConnectionRequest` calls, including outgoing trace context. It sends its recorded spans through the backend rather than carrying your collector credentials.
+
+For browser apps, context propagation is limited to the relay host and configured `propagateTo` hosts. A cross-origin service must allow the tracing headers in CORS. The [client tracing walkthrough](/blog/follow-a-tap-with-opentelemetry/) covers consent, propagation and the supported span types.
+
+That connects the experience on the device to the work behind it. A server-only trace cannot show the client work before the request or after the response. You can investigate that larger path in your enterprise tracing system instead of keeping a separate, disconnected account of what the app did.
+
+
+Database spans record SQL as supplied, with placeholders intact; bound parameters are not recorded. If an application concatenates a secret into SQL, the resulting text already contains it. `cn1.otel.attributes.exclude=db.query.text` can exclude that attribute. Parameterized SQL remains the better habit.
+
+WebSocket lifetime is outside this automatic request-span model. An hours-long connection with thousands of messages is not one useful HTTP request duration, and its upgrade is handled before this tracing path.
+
+## Send it to the system your team already uses
+
+For an enabled build, configure a collector at runtime:
+
+```bash
+export OTEL_SERVICE_NAME=orders-native
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318
+export OTEL_TRACES_SAMPLER=parentbased_traceidratio
+export OTEL_TRACES_SAMPLER_ARG=0.1
+./build/Orders
+```
+
+Here `Orders` is the packaged application's executable. The ratio samples a tenth of newly rooted traces; the parent-based policy respects an upstream sampling decision.
+
+The exporter uses OTLP over HTTP, with protobuf by default and JSON as an option. It does not implement OTLP/gRPC. It appends `/v1/traces` or `/v1/metrics` to the base endpoint unless you supply a signal-specific endpoint.
+
+Dynatrace can receive that OTLP data. For traces, its [documented ingest endpoint](https://docs.dynatrace.com/docs/ingest-from/opentelemetry/otlp-api) is configured through `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, with an ingest credential in `OTEL_EXPORTER_OTLP_HEADERS`. This uses explicit telemetry export; the translated server no longer has the JVM hooks used by Java instrumentation agents.
+
+A dedicated exporter thread batches spans. If the collector is slow or unavailable, request handling does not wait indefinitely for it. A bounded queue eventually drops spans and records the drops. That preserves the service at the cost of incomplete telemetry, which is itself a condition to monitor.
+
+## Track latency without a metric for every URL
+
+The server records request duration, active requests, open connections, database pool counts and task queue depth. Scheduled jobs report duration and outcome. The default metric export interval is one minute, using cumulative temporality.
+
+Route labels use `/orders/{id}`, not `/orders/81379`. Putting each order ID into a metric label would create a new time series for every order. Templates keep the series count bounded by the API's shape.
+
+The application can instrument a method too:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.Counted;
+import com.codename1.backend.annotations.Component;
+import com.codename1.backend.annotations.Timed;
+
+@Component
+public class QuoteService {
+ @Timed
+ @Counted
+ public int quoteCents(int quantity) {
+ if (quantity < 1) {
+ throw new IllegalArgumentException("quantity must be positive");
+ }
+ return quantity * 250;
+ }
+}
+```
+
+This deliberately small example creates a duration histogram and call counters, including a failure counter. The default instrument names derive from the class and method. The build weaves the measurement into the method, so a call through `this` is measured too. For a real quote service, validate upper bounds and apply the application's monetary rules.
+
+`@ManagedResource`, `@ManagedAttribute` and `@ManagedOperation` offer a JMX-inspired model for current values and operator actions. Numeric managed getters become gauges. The management transport is the backend's own HTTP API; this is not a JVM JMX server hidden inside the native executable. Follow the [management configuration](/developer-guide/backend-observability/) before exposing operational actions.
+
+## Let an agent check the running application
+
+MCP, the Model Context Protocol, gives a development tool a structured way to ask the server questions. The backend serves tools for listing routes, inspecting beans, reading recent requests and querying the database. After editing a handler, you can call it and inspect the row it wrote from your development tool.
+
+A practical loop is:
+
+1. Start the backend on its development profile.
+2. Inspect `backend_routes`, `backend_beans` and `backend_schema`.
+3. Make the edit, then stop and restart the server. There is no hot reload.
+4. Exercise the handler with `backend_call`.
+5. Check `backend_requests`, `backend_sql` and `backend_metrics`.
+
+The default SQL tool uses a database-enforced read-only transaction unless its caller explicitly requests write access. An application can publish its own methods with `@McpTool`; the build derives JSON Schema from their supported parameter types and calls them directly.
+
+For a tool of your own, here is a complete bean using the generated dispatch:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.McpParam;
+import com.codename1.backend.annotations.McpTool;
+import com.codename1.backend.annotations.Component;
+
+@Component
+public class QuoteTools {
+ private final QuoteService quotes;
+
+ public QuoteTools(QuoteService quotes) {
+ this.quotes = quotes;
+ }
+
+ @McpTool(description = "Returns a quote in cents for a positive quantity.")
+ public int quote(@McpParam("quantity") int quantity) {
+ return quotes.quoteCents(quantity);
+ }
+}
+```
+
+It reuses `QuoteService` above. The description tells an agent when the tool is relevant, and `@McpParam` supplies a stable argument name independent of compiler parameter metadata. Runtime authentication still has to be configured before serving it outside development.
+
+Development tools are omitted by `backendPackage` / `cn1:backend-package` unless deliberately enabled. Outside development, the MCP endpoint requires a bearer token. A tokenless development server is restricted to loopback. Origin checks also matter when a browser can reach that machine. The [MCP chapter](/developer-guide/backend-mcp/) spells out these boundaries.
+
+## Keep collector credentials off the phone
+
+An app can send its own spans through the backend relay. The relay validates the OTLP/JSON payload, applies size and span-count limits, then queues it for export using credentials held by the server.
+
+```properties
+cn1.otel.relay=true
+cn1.otel.relay.token=${RELAY_TOKEN}
+cn1.otel.relay.corsOrigin=https://app.example.com
+```
+
+The CORS setting is for a web app on another origin. An app-carried relay token is not an unextractable secret; the collector's ingest credentials should remain on the backend. A full queue returns 503 so the client can back off.
+
+Start with one real app action that crosses the native backend and an existing enterprise service. Verify that its spans share a trace ID in your collector, then check consent, sampling, queue drops and access to the relay before expanding collection. The goal is to make the app and its native server observable parts of the system your operations team already runs.
+
+---
+
+## Discussion
+
+_Which part of your application is hardest to connect to an end-to-end trace?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/parparvm-four-byte-header.md b/docs/website/content/blog/parparvm-four-byte-header.md
new file mode 100644
index 00000000000..6d942389d97
--- /dev/null
+++ b/docs/website/content/blog/parparvm-four-byte-header.md
@@ -0,0 +1,164 @@
+---
+title: "Honey, I Shrunk Java"
+slug: parparvm-four-byte-header
+url: /blog/parparvm-four-byte-header/
+date: '2026-10-03'
+author: Shai Almog
+description: "ParparVM translates its compiler with 37.5% less time and 45.8% less peak memory in the Linux ARM64 baseline. See the object, compiler and GC changes behind it."
+feed_html: ' ParparVM translates its compiler with 37.5% less time and 45.8% less peak memory in the Linux ARM64 baseline. See the object, compiler and GC changes behind it.'
+series: ["release-2026-10-02"]
+---
+
+
+
+The current Linux ARM64 performance baseline has ParparVM translating its own compiler in **37.5% less elapsed time and 45.8% less peak memory than JDK 25**. On the Linux x64 `Xeon Platinum 8370C` baseline, the same workload takes **56.6% less time and 49.1% less memory**. Your Java source does not need to change to benefit from a smaller runtime and a compiler that removes more work.
+
+[](/blog/runtime-diagrams/translation-baselines.png)
+
+These are the repository's [checked-in performance baselines](https://github.com/codenameone/CodenameOne/blob/60c4f310bddcfc51e5acc75c63a57c43c73430d3/vm/selfhost/perf-baseline.json), read on October 1. They are recorded reference results used to detect regressions, not new measurements made for this article. Each comparison runs the same translator classes on the two runtimes and verifies the generated files byte for byte.
+
+| Self-translation baseline | Elapsed time, ParparVM / JDK 25 | Peak memory, ParparVM / JDK 25 | Recorded calibration runs |
+| --- | ---: | ---: | ---: |
+| Linux ARM64, Neoverse N2 | 0.625 | 0.542 | 7 |
+| Linux x64, EPYC 7763 | 0.484 | 0.519 | 3 |
+| Linux x64, Xeon Platinum 8370C | 0.434 | 0.509 | 3 |
+
+*Lower is better in both columns. JDK 25 is 1.0. Each baseline is the median of the recorded runs' median ratios, with each platform using its available CPUs and runtime defaults. Translation time includes the whole process; Linux memory is peak RSS. They are separate machines, not a core-count scaling test.*
+
+A couple of weeks ago I wrote about [making ParparVM compile itself](/blog/parparvm-compiles-itself/). HotSpot beat us on elapsed time. That was disappointing, though hardly surprising. Since then we have worked on object layout, collections, generated C and garbage collection. The results above are a much better place to be.
+
+The smaller objects matter beyond the compiler benchmark. In [Friday's server comparison](/blog/java-server-work-before-startup/), CN1's native backend peaks at **`57.8 MiB` RSS**, against **`117.0 MiB`** for Spring/GraalVM, and rests at **`29.8 MiB`** after load against **`79.6 MiB`**. That compares complete HTTP stacks. Here we will look at the runtime changes that help make a smaller Java process possible.
+
+## What gets faster, and what still needs work?
+
+Self-translation is a substantial Java workload: allocating objects, walking collections, resolving methods and writing generated C. It is also our own compiler, so we should check other workloads before treating it as a verdict on Java performance.
+
+The complete Linux ARM64 baseline contains 13 workloads. ParparVM uses less peak memory in all 13 and less elapsed time in eight. Sequential array access takes 0.362 times the JDK's measured time; hash-map churn uses 0.121 times its peak process memory. Allocation remains an important weakness: that workload takes 3.043 times the JDK's time, even while using 0.239 times its peak memory.
+
+[](/blog/runtime-diagrams/arm64-baselines.png)
+
+*Each row combines seven calibration runs; each run compares the two runtimes in alternating order. Translation rows measure the complete process. The smaller workloads time repetitions inside the process after their own warmup, so JVM startup does not count against HotSpot. Memory is whole-process peak RSS in every row, not live heap.*
+
+The [performance harness](https://github.com/codenameone/CodenameOne/blob/master/vm/selfhost/perf-gate.py) checks workload results as well as time and memory. The current baseline is a different comparison from the earlier experiment using a warmed JDK 25 AOT cache. In that experiment, self-translation used 0.74, 0.76 and 0.84 times HotSpot's elapsed time at one, two and four logical cores. That cache is part of HotSpot's startup work, not a GraalVM native executable.
+
+Elapsed time and CPU time also answer different questions. Parallel JIT compilation and collection can reduce the wait while consuming more CPU across threads. That distinction helped guide the investigation, but it does not establish a battery saving: energy depends on the machine's power use over time. The current baseline records elapsed time and peak memory, so those are the claims we can make from it.
+
+## Why a tiny Java object needs a header
+
+An object header is runtime metadata stored alongside your fields. It lets the runtime identify the object's class and track information needed for collection and other operations. On a typical 64-bit HotSpot configuration, the header occupies 12 bytes; without compressed class pointers it can occupy 16. JDK 25's optional compact object headers reduce that to 8 bytes. [Oracle's JDK 25 GC guide](https://docs.oracle.com/en/java/javase/25/gctuning/other-considerations.html) documents the sizes and the `-XX:+UseCompactObjectHeaders` switch.
+
+This is the work associated with **Project Lilliput**. **Project Leyden** addresses startup, warmup and footprint through ahead-of-time work, including the AOT cache used in the earlier comparison. The names are easy to mix up, but shrinking each object's header and caching class-loading work solve different problems. See the [Leyden project](https://openjdk.org/projects/leyden/) for that distinction.
+
+| Runtime layout | Object header metadata | What the number excludes |
+| --- | ---: | --- |
+| HotSpot, compressed class pointers | 12 bytes | Fields, alignment and backing storage |
+| HotSpot, JDK 25 compact headers enabled | 8 bytes | Fields, alignment and backing storage |
+| ParparVM release layout | 4 bytes | Fields, alignment, side tables and backing storage |
+
+These are layout sizes, not a prediction of process memory. A small HTTP server can spend more of its resident memory on stacks, code, allocator pages and library state than on live Java object headers. The [server comparison](/blog/java-server-work-before-startup/) measures the whole process separately.
+
+The release object header carries a 16-bit class index, an 8-bit collection epoch and an 8-bit heap state. The class index addresses a closed-world class table instead of storing a pointer in every object. Objects requiring a legacy heap index use a side table keyed by address.
+
+[](/blog/runtime-diagrams/object-header.svg)
+
+The [runtime header](https://github.com/codenameone/CodenameOne/blob/master/vm/ByteCodeTranslator/src/cn1_globals.h) is explicit about the distinction between metadata and allocation. The C header struct remains eight-byte aligned. Small objects live in allocator size classes, and fields need alignment too. A four-byte header does not make an empty object a four-byte allocation.
+
+The translator packs eligible fields into the gap after the metadata. It stores fields at their real widths and orders them to reduce padding. A subclass must preserve its superclass layout as a prefix, so it cannot arbitrarily reach back and fill a hole belonging to an ancestor. That restriction sharply reduced the savings predicted by an early census.
+
+| Object in the experiment | Before | After four-byte header and root-field packing |
+| --- | ---: | ---: |
+| `VarOp` | 32 bytes | 24 bytes |
+| `ArrayList` | 32 bytes | 24 bytes |
+| `ByteCodeMethodArg` | 32 bytes | 24 bytes |
+| `BasicInstruction` | 40 bytes | 32 bytes |
+
+*Object sizes from the layout experiment. Backing storage is additional.*
+
+In the same five-run comparison, this layout change moved one-core container RSS from 618 MB to 605 MB. That is useful, but much smaller than “we halved the header” might suggest. The page allocator and native collection buffers still occupy memory.
+
+There was a second trap. A static class table that named every class also kept those classes reachable to the native linker. The current implementation registers most entries as classes are used. Shrinking object metadata should not accidentally force otherwise unused classes into the executable.
+
+## Get less overhead from the same Java loop
+
+ParparVM translates bytecode to C. “Lowering” is the step that turns a higher-level operation into a representation the native compiler can optimize directly. We do not get that benefit merely by giving Clang a large pile of C functions.
+
+Consider a collection traversal. The ordinary implementation has an iterator object and virtual calls for `hasNext()` and `next()`. When the translator proves the exact collection layout, it can emit a native cursor loop. When it cannot prove the receiver, it can check the exact class once and retain the ordinary iterator as a fallback.
+
+{{< mermaid >}}
+flowchart TD
+ Loop[Collection traversal] --> Proof{Exact supported layout?}
+ Proof -->|Proved locally| Cursor[Native cursor loop]
+ Proof -->|Unknown receiver| Guard[Check exact class once]
+ Guard -->|Matches| Cursor
+ Guard -->|Other class| Iterator[Ordinary iterator]
+ Cursor --> Rules[Keep owner alive and preserve modification checks]
+{{< /mermaid >}}
+
+The owner must remain a GC root until the final native-buffer access. A raw pointer into a `malloc` block does not keep the Java owner alive. The emitted lifetime fence is therefore part of correctness, not optional bookkeeping to strip from a fast loop.
+
+Several related changes attack allocation and dispatch:
+
+- **Collection storage:** hash tables combine key, value and metadata slices into one native allocation. Reference slices still need tracing and write barriers. Moving them outside the managed heap does not make their Java references invisible to the collector.
+- **Strings and builders:** `StringBuilder` keeps Latin-1 bytes until it needs UTF-16. Proven temporary builders can use native storage while preserving ownership across helper calls and exceptions. `StringBuffer` retains its synchronization.
+- **Short string equality:** bounded loads compare short strings without an ordinary Java method call. Longer ranges still use `memcmp`; mixed encodings preserve their own comparison rules. The implementation must not read past the logical range just because a wide load would be convenient.
+- **Immediate array streams:** supported `Stream.of(array)` pipelines with known lambda callbacks can become one C loop. Escaping streams, unknown callbacks, `sorted`, `distinct` and unsupported terminals keep the lazy implementation.
+
+For example, this shape is eligible for the stream work when the surrounding method satisfies the proof:
+
+```java
+long count = java.util.stream.Stream.of(names)
+ .filter(name -> name.length() > 3)
+ .count();
+```
+
+Here `names` is a `String[]`. Eligibility is narrower than “streams allocate nothing.” Nor does seeing a loop in emitted C prove that the linked binary vectorizes it. The lowering audit checks generated code and linked instructions separately from elapsed-time measurements.
+
+## Keep your program correct when removing work
+
+A declared `List` type does not prove an `ArrayList` layout. `LocalReceiverTypes` tracks allocation provenance, and unknown parameters or factory results retain guards. Analysis is restricted to methods that need it, and the compiler drops the temporary frame information after capturing the proof. Optimizing the translated program should not require keeping an unnecessary analysis graph alive throughout translation.
+
+Direct calls also gain small C intrinsics for operations such as list access, string length, hashing and builder appends. They apply to calls whose target is resolved statically, with the ordinary implementation available off the fast path. Together with traversal lowering, this lets the C compiler see useful operations inside a loop instead of opaque calls at every step.
+
+Another pass removes instance fields the closed program never reads. It checks native-source references and conservatively keeps runtime fields and unresolved cases. Removing a dead reference field can save both its storage and the object it would otherwise retain. This pass is disabled for JavaScript output and on-device debugging.
+
+There is a semantic edge worth stating: the current [dead-field pass](https://github.com/codenameone/CodenameOne/blob/master/vm/ByteCodeTranslator/src/com/codename1/tools/translator/DeadFieldElimination.java) documents that assigning to a removed field on a null receiver no longer produces the JVM's `NullPointerException`. Its treatment of an unused store is therefore not a claim of identical behavior for every Java program. An application depending on that exception needs to account for this difference.
+
+## Fit the collector to the cores you have
+
+The small-object allocator groups objects into pages by size, often called BiBOP, short for “big bag of pages.” A nonmoving collector cannot return a page while one live object still occupies it. Free slots inside a partial page can be reusable capacity without being releasable memory.
+
+The experiments found 50 to 60 MB of free slots inside partial pages around one peak. Those slots were reused before new pages were allocated. Calling all of that a leak would send the investigation in the wrong direction.
+
+On one core, the generational collector can stop application work and collect young objects. With spare cores, the concurrent collector overlaps tracing with the application. The concurrent path needs grace for allocations that appear after a snapshot. That can retain dead objects longer, and shortening that lifetime requires preserving everything the snapshot could not yet see.
+
+We tried reclaiming dead large objects every single-core cycle. The first attempts were unsound. A growing output buffer could be allocated after the extent snapshot and remain live only in a thread's local state. If the collector could not resolve that pointer, it could free a live buffer.
+
+The fix registers those large objects from allocation and rebuilds the relevant snapshot at each thread's pause in that mode. The concurrent collector keeps its different grace rules. Applying one mode's shortcut to the other added locking to a hot path without providing a benefit.
+
+| One-core translation, five interleaved rounds | Minimum elapsed | Maximum RSS |
+| --- | ---: | ---: |
+| JDK 25 | 13.74 s | 557 MB |
+| Four-byte header before reclamation change | 10.29 s | 608 MB |
+| With large-object reclamation change | 9.84 s | 503 MB |
+
+*Linux container experiment isolating the reclamation change: minimum elapsed and maximum RSS from five interleaved runs. Lower is better. These historical results explain the change; the opening charts show the current baseline.*
+
+We then reduced work in minor collections: skip an already-old page object before expensive conservative resolution, and consult the monitor table only for pages that have had monitors. The experiment record includes the unsuccessful alternatives too. Fewer object bytes help memory use. Avoiding thousands of unnecessary collector operations helps execution time too.
+
+## What changes for your app?
+
+If your application creates large graphs of small objects, the smaller headers and field packing can reduce their cost without a source rewrite. Proven collection traversals and stream pipelines can avoid temporary objects and dispatch. These are compiler and runtime changes, so you get them by rebuilding with a release that includes this work.
+
+The benefit depends on what your app spends time and memory doing. A form with a large model, an importer that walks collections, and a service that allocates objects continuously stress different parts of the runtime. The allocation result above is a reason to check a busy handler before assuming it will behave like the compiler benchmark.
+
+For an existing Codename One app, rebuild and compare a real interaction on your target device: startup, a large list or model load, and a sustained operation that creates objects. For a backend, compare resident memory at rest and under representative traffic, plus throughput and latency. Keep the input and build settings the same between releases. The [backend guide](/developer-guide/backend/) covers packaging a small service you can test this way.
+
+There is more room to improve. Our measurements point toward shorter-lived garbage in the concurrent collector and less overhead in small native collection buffers. A stop-the-world strategy saves memory on one core, but forcing it everywhere can lose too much execution time. The next step is to reduce that retention while preserving useful concurrency. That is an optimization direction, not a promise that one collector will win on every application.
+
+---
+
+## Discussion
+
+_When you compare runtimes, do you record CPU time as well as the time you waited?_
+
+{{< giscus >}}
diff --git a/docs/website/static/blog/browser-desktop-theme.jpg b/docs/website/static/blog/browser-desktop-theme.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..eafe827bf2adc5226b75b4d2bbf7b02fc7d027eb
GIT binary patch
literal 65333
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
Use macOS, Windows or Linux desktop styling in the JavaScript port, with an optional HTML menu bar, and see how the same theme work reaches the Certificate Wizard.'
+series: ["release-2026-10-02"]
+---
+
+
+
+You can give your Codename One web app the same desktop theme family as your users' operating system: Aqua on macOS, Fluent on Windows, or Adwaita on Linux. Menus can sit above the app in HTML, with commands such as File and View visible instead of tucked into a mobile overflow menu.
+
+That gives you a browser version of your app that fits more comfortably on a desktop. The JavaScript port now supports both choices, and the same theme work reaches the Certificate Wizard you use to sign your apps.
+
+## Follow the operating system, or choose a theme
+
+Set these in the Settings app's **Build Hints**:
+
+```properties
+nativeTheme=native
+javascript.titleBar=html
+```
+
+In `codenameone_settings.properties`, use `codename1.arg.nativeTheme` and `codename1.arg.javascript.titleBar` instead. Desktop browsers select Fluent for Windows, Aqua for macOS, and Adwaita for Linux and the remaining desktop systems. Phones and tablets keep the mobile theme selection. The browser detection treats an iPad as a tablet even when it reports a Mac browser.
+
+These are Codename One themes drawing the controls. They are not the operating system's native widget toolkit embedded in the page.
+
+[](/blog/desktop-theme-collage.jpg)
+
+*The Settings app demonstrates the three desktop theme families now available to browser apps. Click to compare the controls at full size.*
+
+You can pin a desktop theme when the application's design calls for it:
+
+```properties
+javascript.desktopTheme=fluent
+```
+
+The other explicit choices are `aqua`, `adwaita` and `none`. `none` keeps mobile themes on desktop browsers. Leave the value at `auto` to follow the operating system. The broader `nativeTheme=modern` setting has different behavior: it selects the modern mobile families, including on desktop browsers. Use `native` when desktop family selection is what you want.
+
+## Put commands above the app
+
+The default `javascript.titleBar=toolbar` keeps the themed Toolbar inside the app. With `html`, the page supplies title and menu bars instead. The title follows the current form; commands group into menus using the same `Command.setDesktopMenu()` hint used on the desktop ports.
+
+For example, inside an initialized app:
+
+```java
+com.codename1.ui.Form form = new com.codename1.ui.Form("Notes");
+com.codename1.ui.Command refresh = new com.codename1.ui.Command("Refresh") {
+ public void actionPerformed(com.codename1.ui.events.ActionEvent event) {
+ form.setTitle("Notes refreshed");
+ }
+};
+refresh.setDesktopMenu("View");
+form.getToolbar().addCommandToOverflowMenu(refresh);
+form.show();
+```
+
+Commands without a menu hint go into a **Commands** menu. The HTML bars follow the selected appearance and the browser's light or dark preference. They do not have fake minimize, maximize or close buttons: the page does not own the browser window. The browser tab title remains the application's display name.
+
+{{< mermaid >}}
+flowchart TD
+ Commands[Toolbar commands and menu hints] --> Mode{Title bar setting}
+ Mode -->|toolbar| Inside[Themed Toolbar inside the app]
+ Mode -->|html| Outside[HTML title and menu above the app]
+ Outside --> Action[Dispatch to the same Command]
+ Inside --> Action
+{{< /mermaid >}}
+
+The source is in [JavaScriptDesktopChrome](https://github.com/codenameone/CodenameOne/blob/master/Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/JavaScriptDesktopChrome.java), with build-hint and page behavior documented in the [JavaScript guide](/developer-guide/working-with-javascript/).
+
+## Keep navigation inside your browser app
+
+We do not support additional native `Window` surfaces in the JavaScript port. Popup blockers and the browser's window ownership make that a different promise from drawing a menu inside the current page. **Windows browsers are supported; extra OS windows are the unsupported feature.** Dialogs and navigation within the app remain the appropriate model.
+
+There are renderer limits too. For example, the full lifted-lens optics from [Sunday's iOS article](/blog/ios27-glass-from-measurements/) are not implemented in the browser. Try the actual controls and effects your app uses rather than assuming a theme name proves complete renderer parity.
+
+The build prunes theme resources it can prove the app will not reach. If your code constructs resource names dynamically, set `javascript.pruneThemes=false`; otherwise a theme loaded only through that constructed name may be missing.
+
+## Use the same desktop styling when you sign your app
+
+A gallery of buttons cannot tell us whether an application works comfortably with a desktop theme. The Certificate Wizard has longer forms, tables, dialogs and instructions that people must actually read to finish a task.
+
+[PR #5916](https://github.com/codenameone/CodenameOne/pull/5916) adopts the native desktop themes there, continuing the work we did in Settings. Its current source uses `@DesktopBuild(themeMode = "native", titleBar = DesktopTitleBar.NATIVE, ...)`, with interactive scrollbars. Fluent, Aqua and Adwaita now provide the surrounding control styles instead of a separate wizard-specific desktop imitation.
+
+The same change fixes handling of an App ID's team prefix. That is a separate functional repair, not a consequence of adopting a theme. The wizard's [current source](https://github.com/codenameone/CodenameOne/tree/master/scripts/certificatewizard) keeps both changes visible.
+
+Try the browser theme with a form that has real commands and enough content to scroll. Switch appearances, open its menus and check keyboard navigation. That will teach you more than another screenshot of an isolated button.
+
+The [weekly overview](/blog/java-server-work-before-startup/) links the rest of the release. It also includes this week's smaller map-label improvement.
+
+---
+
+## Discussion
+
+_For a browser version of a desktop app, which commands deserve a visible menu?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/friday-release-better-gates.md b/docs/website/content/blog/friday-release-better-gates.md
new file mode 100644
index 00000000000..f54857f37d4
--- /dev/null
+++ b/docs/website/content/blog/friday-release-better-gates.md
@@ -0,0 +1,113 @@
+---
+title: "Don't Order Fish on Monday. Don't Release on Friday"
+slug: friday-release-better-gates
+url: /blog/friday-release-better-gates/
+date: '2026-10-08'
+author: Shai Almog
+description: "A difficult release week exposed an Apple API failure that passed device tests, leading to source and binary checks for undeclared SDK imports."
+feed_html: '
A difficult release week exposed an Apple API failure that passed device tests, leading to source and binary checks for undeclared SDK imports.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Anthony Bourdain's famous warning about Monday fish was a warning about the supply chain behind the menu. In his [1999 essay](https://www.newyorker.com/magazine/1999/04/19/dont-eat-before-reading-this), he described seafood bought for the weekend still being served on Monday. Knowing how the kitchen worked changed what he would order.
+
+Developers have a similar rule: never release on Friday. If something breaks, you have just made plans for everyone's weekend. It is excellent advice that we have ignored for years.
+
+We settled on Friday releases to avoid dropping a framework update into the middle of our customers' release week. The idea was to use the quieter window to test and repair our release before it collided with theirs. That assumes a lot about when other people ship. It has also cost me plenty of weekends.
+
+This time the problems consumed much of the week. There were regressions around the optional Xcode 27 path, push, and windows. Some overlapped, so a fix could make the original symptom disappear while the underlying problem resurfaced elsewhere. That is exhausting for us, and it is worse for the customer trying to finish an app.
+
+## Catch a rejection your device tests can miss
+
+One failure was especially instructive. Apps using particular crypto APIs could compile, link and run, then fail App Store Connect submission because the binary imported non-public symbols. Most apps did not enable the affected code, so most users and our usual tests never encountered it:
+
+```text
+_CCCryptorGCMAddAAD
+_CCCryptorGCMAddIV
+_CCCryptorGCMFinal
+```
+
+The SDK's libraries exported these symbols. The linker could resolve them. But they were not declared in the public headers. A successful link did not establish that they were public APIs suitable for submission.
+
+Our tests had another blind spot: the calls sat behind an optional feature gate that the sample app did not normally enable. Testing the same sample more often would not make that branch appear.
+
+The [new checker source](https://github.com/codenameone/CodenameOne/blob/master/scripts/check-ios-private-api.py) preserves the rejection and the causal chain. It is a more useful record than a claim that we “added more tests.”
+
+## How your build could enable a feature you never requested
+
+The builder enabled a feature by replacing a preprocessor definition. A plain string replacement for one name also matched the start of a longer name:
+
+```c
+#define CN1_INCLUDE_CRYPTO
+#define CN1_INCLUDE_CRYPTO_GCM
+```
+
+Enabling general crypto could therefore enable the GCM path too. The customer did not have to request that optional path to compile its imports.
+
+The fix makes the builder match the whole definition name. A focused regression test guards that behavior. The GCM implementation itself was rewritten using public CommonCrypto operations and a C implementation of GHASH, the authentication calculation. The authenticated-decryption path verifies the tag before releasing decrypted output.
+
+A separate sweep found `sqlite3_key` and `sqlite3_rekey` imports that were valid for the bundled cipher engine but not public declarations in Apple's SQLite headers. Those imports now depend on the bundled engine defining them. One rejected upload exposed more than one place where “the symbol links” had stood in for “the symbol is public.”
+
+## How we will catch this class of failure before it reaches you
+
+A regression test for the three names would catch those three names returning. We also need a check for the broader mistake: importing an SDK symbol that has no public declaration.
+
+The new gate asks that question in two ways:
+
+| Check | What it sees | Why it is needed |
+| --- | --- | --- |
+| Source mode | Native port sources with feature gates enabled and optional-engine variants | The ordinary sample does not exercise every feature combination |
+| Binary mode | Imports in a linked Release device app and the covered bundled components | The final link can contain code beyond the port source sweep |
+
+{{< mermaid >}}
+flowchart TD
+ Source[Native sources and feature variants] --> Compile[Compile the covered configurations]
+ Compile --> Imports[Collect SDK imports]
+ Binary[Linked Release device app] --> Imports
+ SDK[Public SDK headers] --> Compare[Compare exported names with declarations]
+ Imports --> Compare
+ Compare --> Fail[Fail on undeclared imported symbols]
+ Probe[Known private and public control symbols] --> Verify[Verify the checker can distinguish them]
+ Verify --> Compare
+{{< /mermaid >}}
+
+The checker uses SDK export information to identify the library symbols and scans public headers with comments removed. A name mentioned in a comment is not accepted as a declaration. It also exercises known private and public controls before trusting a clean result. A check that can never report a failure is a very comforting way to learn nothing.
+
+For a local inspection of a linked app, the script exposes a binary mode:
+
+```bash
+python3 scripts/check-ios-private-api.py \
+ --binary /path/to/Release-iphoneos/MyApp.app --sdk iphoneos
+```
+
+Replace the example path with your Release device artifact; use `--developer-dir` if the SDK belongs to a different Xcode installation. The repository wires source mode and Release binary mode into its iOS checks. [PR #5923](https://github.com/codenameone/CodenameOne/pull/5923) contains the implementation and the builder repair.
+
+## Know what your submission check covers
+
+This is an imported-symbol check for the covered C and Objective-C surface. It skips Swift and C++ mangled names that cannot be matched by this header scan, and it does not inspect private Objective-C selectors. The binary check in the repository runs against the covered sample and bundled components, not every arbitrary dependency a customer might add.
+
+It also cannot predict every App Store review decision. Entitlements, privacy declarations and application behavior are different questions. Checking imports catches one specific reason for rejection before you upload.
+
+Review those remaining checks separately when preparing your submission.
+
+## We owe you more reliable releases
+
+This week was hard. I spent too much of it chasing regressions, and some of you spent time proving to us that a fix had not really fixed your problem. That is time you should have been able to spend on your own apps. Our release process needs to do better.
+
+Changing the day we ship would not repair the gaps that let these failures through. Our plan is to strengthen the gates around the things we deliver: exercise optional configurations, check the final artifacts, and test rules that cover a whole class of mistakes. We still need the small regression test for each bug. We also need to ask why that bug could reach a customer while the checks were green.
+
+The private API gate is one concrete step in that plan. It checks feature combinations our regular sample missed, examines a linked Release app, and uses known control symbols to verify that the checker can actually fail. The wider work is ongoing; one new gate does not solve every regression involving Xcode, push, or windows.
+
+I cannot promise next week will be quiet. I can promise that a difficult week should leave us with stronger release checks, not just a longer list of closed bugs. As that coverage grows, fewer failures should depend on a customer finding the right combination of APIs for us.
+
+This closes the [weekly series](/blog/java-server-work-before-startup/). I am excited about the backend and the UI improvements, but you should be able to try them without wondering what else an update will break. That is the release quality we need to earn.
+
+---
+
+## Discussion
+
+_Which green check has given your team the most misleading confidence before a release?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/gradle-smaller-projects.md b/docs/website/content/blog/gradle-smaller-projects.md
new file mode 100644
index 00000000000..866d0ff3ae0
--- /dev/null
+++ b/docs/website/content/blog/gradle-smaller-projects.md
@@ -0,0 +1,182 @@
+---
+title: "Do You Prefer Gradle?"
+slug: gradle-smaller-projects
+url: /blog/gradle-smaller-projects/
+date: '2026-10-05'
+author: Shai Almog
+description: "Optional Gradle projects remove empty platform modules, support standalone backends, and use the same build engine as Maven."
+feed_html: '
Optional Gradle projects remove empty platform modules, support standalone backends, and use the same build engine as Maven.'
+series: ["release-2026-10-02"]
+---
+
+
+
+You can now choose Gradle for a Codename One project. Start with fewer files, add platform directories when you need native code, or create a standalone backend without a mobile app attached. A smaller project is easier to browse and leaves less scaffolding competing for space in an LLM's context.
+
+I like Maven XML. I know it is verbose. I also spent enough time at Sun Microsystems staring at deeply scripted, heavily patched `make` files to develop a lasting suspicion of clever build systems.
+
+Someone starts with a reasonable shortcut. Someone else needs one more condition. A few years later the build has its own undocumented programming language and nobody wants to touch it. I would rather a build system be strict and limited. Give people enough power and, with the best intentions, they build a Frankenstein build.
+
+That is a personal preference. Plenty of developers I respect love Gradle, or at least appreciate what it lets them do. This week we added [optional Gradle support](https://github.com/codenameone/CodenameOne/pull/5922) because it lets us offer something useful: a smaller Codename One project, including a standalone backend with no client scaffolding.
+
+## Start with fewer files
+
+The Maven app layout has a root POM and platform modules ready for native code. That makes the structure explicit, but a new app often has no code in most of those places.
+
+A Gradle app starts with the sources and configuration it needs. Native directories appear when you generate native interfaces. A backend subproject appears when you add a backend.
+
+For a concrete example, we converted the checked-in HelloCodenameOne sample with the current converter:
+
+| Project files | Maven sample | Converted Gradle sample |
+| --- | ---: | ---: |
+| Total files, including app sources and resources | 358 | 305 |
+| Maven POMs | 9 | 0 |
+| Gradle Kotlin configuration files | 0 | 2 |
+
+That removes **53 files, about 15% of the tree**. We counted the tracked sample before conversion and all files in the converter's new directory afterward, excluding build output and caches. This is the existing demonstration app, with its resources and Kotlin source, rather than a comparison of two different Hello World programs.
+
+The generated `settings.gradle.kts` is small enough to show in full, with its explanatory comments removed:
+
+```kotlin
+pluginManagement {
+ repositories {
+ maven("https://repo.codenameone.com/maven2")
+ gradlePluginPortal()
+ }
+}
+plugins {
+ id("com.codenameone") version "8.0-SNAPSHOT"
+}
+rootProject.name = "HelloCodenameOne"
+```
+
+The sample conversion uses the development version. Select the release containing this support when it is available. The app's own dependencies and Kotlin plugin go in `build.gradle.kts`; the framework's platform builders come from the Codename One plugin.
+
+
+```text
+MyApp/
+ settings.gradle.kts
+ gradle.properties
+ gradlew
+ gradle/wrapper/
+ codenameone_settings.properties
+ icon.png
+ src/main/java/
+ src/main/css/theme.css
+ src/main/resources/
+```
+
+Add `build.gradle.kts` when you have dependencies or build configuration of your own. Kotlin source belongs in `src/main/kotlin` when the project applies the Kotlin plugin.
+
+That smaller tree helps a human understand an unfamiliar project. It can also reduce the irrelevant files an agent sees when building its context. The file reduction is measurable; the context saved depends on which files your agent reads.
+
+## Keep the same builds when you switch
+
+We did not implement a second set of platform builders. The Gradle plugin calls the shared engine used by Maven. That includes upload staging, local builders, CSS compilation and bytecode compliance checks.
+
+{{< mermaid >}}
+flowchart TD
+ Maven[Maven plugin] --> Engine[Shared Codename One build engine]
+ Gradle[Gradle plugin] --> Engine
+ Engine --> CSS[Compile CSS and check bytecode]
+ Engine --> Local[Generate local platform projects]
+ Engine --> Upload[Stage cloud build upload]
+{{< /mermaid >}}
+
+From a generated Gradle app:
+
+```bash
+./gradlew run
+./gradlew cn1Test
+./gradlew buildJavascriptLocal
+./gradlew buildIosXcodeProject -Popen=false
+```
+
+`run` starts the simulator. `cn1Test` uses the simulator test runner. The last two commands build the JavaScript port locally and generate an Xcode project. Tasks that submit cloud builds are available too, with the same service requirements as Maven.
+
+There are limits. Running Gradle requires JDK 17 or newer and Gradle 8.5 or newer; the generated wrapper supplies Gradle. These projects target Java 17. They do not support legacy `.cn1lib` files or the old resource Designer task. The OpenAPI, gRPC and GraphQL generators and on-device debugging helpers still have Maven goals without equivalent Gradle tasks. The [workflow chapter](/developer-guide/gradle-project-workflow/) lists the supported surface.
+
+## Build a standalone Java backend
+
+In the [Initializr](/initializr/), choose **Gradle** as the build tool and **Backend only** as the project type. The server lives at the root, with its Java source and application properties. There is no client theme, simulator module or collection of empty native directories.
+
+For a generated project named `MyService`:
+
+```bash
+CN1_PROFILE=dev ./gradlew runBackend
+```
+
+That runs the development server on the JVM. Stop it before changing the backend code; this is a restart workflow, not hot reload. To build and run the native executable:
+
+```bash
+./gradlew backendPackage
+CN1_PROFILE=dev PORT=9000 ./build/MyService
+```
+
+The development profile uses the generated in-memory SQLite configuration. Without it, the starter reads its production settings and expects `DATABASE_URL`. The executable's name follows the project name.
+
+An existing Gradle app can gain a server with:
+
+```bash
+./gradlew addBackend
+CN1_PROFILE=dev ./gradlew :backend:runBackend
+./gradlew :backend:backendPackage
+```
+
+I hope people will try the backend on its own. It is still experimental, but a small independent service can reveal useful constraints without requiring a mobile application first. The [weekly overview](/blog/java-server-work-before-startup/) shows the Spring-style programming model it now supports.
+
+## Try Gradle alongside your Maven project
+
+The converter leaves the original project in place and writes a sibling project. Replace `VERSION` with the Codename One plugin release containing this feature:
+
+```bash
+mvn com.codenameone:codenameone-maven-plugin:VERSION:convert-to-gradle \
+ -Dcn1.sourceProject=/path/to/MyApp \
+ -Dcn1.outputDir=/path/to/MyApp-gradle
+```
+
+The destination must be empty or absent. The conversion carries sources, resources, CSS and platform implementations into the new layout, and raises the application's bytecode target to Java 17. A customized backend comes across; the untouched backend skeleton is optional. Legacy `.cn1lib` dependencies stop conversion with their names rather than silently disappearing.
+
+Open the converted project and run its tests before switching the team's build. Your old checkout remains available for comparison.
+
+## Find the API for the code you are writing
+
+Last week we split the Developer Guide into chapters. Before that, we rebuilt the Javadocs. A backend-only project made the next problem obvious: a client API page is the wrong answer when you are writing a server.
+
+[PR #5918](https://github.com/codenameone/CodenameOne/pull/5918) separates the [client API](/javadoc/) from the [backend API](/backend/javadoc/). The references label their audience and link shared classes to their counterpart. Backend classes belong in the backend reference; a UI implementation package does not belong there just because it exists in the repository.
+
+| What you are writing | Reference to start with |
+| --- | --- |
+| A form, component or device integration | [Client Javadocs](/javadoc/) |
+| A controller, database service or scheduled job | [Backend Javadocs](/backend/javadoc/) |
+| Shared models and mapping code | The shared class page, with its counterpart link |
+
+The distinction helps readers and code-generation tools for the same reason: it reduces the chance of choosing an API that exists in the wrong runtime. Both references are checked with `doclint`, so malformed documentation has a build-time consequence too.
+
+## Try Gradle 9 for your Android build
+
+The optional Gradle project layout and the Gradle version used inside a generated Android project are different choices. You can keep your Codename One app on Maven and still test the newer Android builder.
+
+In Settings, under **Build Hints**:
+
+```properties
+android.gradleVersion=9
+```
+
+Or in `codenameone_settings.properties`:
+
+```properties
+codename1.arg.android.gradleVersion=9
+```
+
+The current builder pairs Gradle 9.8.0 with Android Gradle Plugin 9.4.1. It adjusts the generated project for removed DSL elements and AGP's built-in Kotlin support. This selects the experimental Gradle 9 / Android Gradle Plugin 9 path from [PR #5919](https://github.com/codenameone/CodenameOne/pull/5919). It is opt-in. Much of the surrounding tooling and library configuration still assumes Gradle 8. Test your actual native dependencies and generated Android project before adopting it; a successful empty app is not the same test.
+
+I expect to keep using Maven for plenty of projects. Supporting Gradle gives teams another way into the same build machinery, and gives a small server a project tree that looks like a small server.
+
+---
+
+## Discussion
+
+_How much freedom do you want a build system to give the next person maintaining it?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/ios27-glass-from-measurements.md b/docs/website/content/blog/ios27-glass-from-measurements.md
new file mode 100644
index 00000000000..389ddabc453
--- /dev/null
+++ b/docs/website/content/blog/ios27-glass-from-measurements.md
@@ -0,0 +1,137 @@
+---
+title: "Can You Tell the Difference Between These iOS Tab Bars?"
+slug: ios27-glass-from-measurements
+url: /blog/ios27-glass-from-measurements/
+date: '2026-10-04'
+author: Shai Almog
+description: "Reconstructing iOS 27 tab motion from real touches, spring equations, color matrices and a side-by-side simulator comparison."
+feed_html: '
Reconstructing iOS 27 tab motion from real touches, spring equations, color matrices and a side-by-side simulator comparison.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Watch the two tab bars below. Tap, hold, drag across the bar, then change direction. Can you tell which one is UIKit and which one is drawn by Codename One?
+
+That is a more useful test than a still image. Your users feel the delay before a selection moves, the way the glass follows a finger and the settling motion after release. A tab bar can have the right colors and still feel wrong in your hand.
+
+[Last week's iOS 27 theme](/blog/ios-27-glass-you-can-test/) was close, but I still wasn't happy with those interactions. Getting closer meant recording UIKit's presentation layers during real touches, fitting the motion to spring equations and reconstructing the glass effects. Here is the result, followed by the measurements and formulas behind it.
+
+## Watch the same gestures twice
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*UIKit is on top and Codename One below. These committed iOS 27 simulator recordings use the same touch sequence: six taps, a held press, a tap on the selected tab, a slow drag and a flick. Each gesture occupies a 4.2-second slot aligned on the touch.*
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*The dark appearance exposes the edge, vibrancy and refraction differences more clearly. UIKit is above Codename One in both simulator recordings.*
+
+The [recording script](https://github.com/codenameone/CodenameOne/blob/master/scripts/record-ios-tabs-side-by-side.sh) and [video notes](https://github.com/codenameone/CodenameOne/blob/master/docs/videos/README.md) make the provenance inspectable. The remaining differences are part of the comparison: the lifted lens, its rounded ends and the saturation still deserve work.
+
+## Why your tab bar can look right and feel wrong
+
+Setting the selected tab in code did not produce the complete native interaction. UIKit performs that motion for genuine touches on a controller-managed bar. The probe therefore uses XCUITest taps, holds, and drags.
+
+There was another complication: UIKit did not attach a simple `CAAnimation` containing the whole trajectory. It updated layer values frame by frame. The useful record was the presentation geometry at each display refresh: position, bounds, transform, opacity and the touch timestamps that explained them.
+
+{{< mermaid >}}
+flowchart LR
+ Touch[Real XCUITest gesture] --> UIKit[Native tab controller]
+ UIKit --> Log[Per-frame presentation geometry]
+ Log --> Fit[Fit springs and retained curves]
+ Fit --> Java[Java motion model]
+ Log --> Fixture[Recorded fixtures]
+ Java --> Check[Replay and compare]
+ Fixture --> Check
+{{< /mermaid >}}
+
+Capturing an image on every frame changes the timing enough to contaminate the measurement. The probe separates geometry logging from optional frame snapshots. Snapshot runs are useful for comparing the lens at the same motion state, not for fitting its timing. Likewise, lossless screenshots over known backdrops reveal the blur; compressed video smears the very edges we need to inspect.
+
+Those constraints are documented in the [native probe](https://github.com/codenameone/CodenameOne/tree/master/scripts/fidelity-app/ios-native-ref/motion-probe). They explain why “looks close in a recording” was not enough.
+
+## Make taps, holds and drags respond differently
+
+For a fixed target, a damped spring follows this equation:
+
+
+
+Here `x` is position, `xₜ` is the target, `ω` controls the natural frequency and `ζ` the damping. Dots denote derivatives with respect to time. A critically damped spring has `zeta = 1`; lower damping allows an overshoot. The implementation uses the measured constants rather than retuning the entire animation by eye:
+
+| Channel | Model in the current source |
+| --- | --- |
+| Selection travel | `omega = 2*pi/0.4`, `zeta = 0.85` |
+| Lens lift | Critical damping, `omega = 2*pi/0.25` |
+| Platter return | Critical damping, `omega = 2*pi/0.4` |
+| Whole-bar press growth | `omega = 17.6`, `zeta = 0.59` |
+| Lens following a drag | `omega = 32`, `zeta = 0.90` |
+
+The travel stops once the remaining distance after the overshoot is below about 0.195 points. The drag and press models include a measured 20 ms touch lag. These small details are visible because your finger gives the animation a moving reference point.
+
+The current [TabGlassMotion](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/TabGlassMotion.java) and [TabGlassGesture](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/TabGlassGesture.java) contain the formulas, retained tables and stopping rules. The regeneration tool checks the closed forms against captures and rewrites the channels that remain tabulated.
+
+## Let users drag across tabs without selecting each one
+
+During a drag the lens follows the finger on its own spring, so it can lag behind. On release, UIKit selects the tab under the finger, not the one nearest the lagging lens. The lens then settles toward that tab from its current position and velocity.
+
+Resetting velocity at that handoff creates a visible interruption. Snapping to the nearest lens position after a fast flick creates another discontinuity. A press on the already selected tab must also lift and pulse without inventing travel to another tab. A held press has to keep its lifted state until release rather than play a fixed-duration tap and finish underneath your finger.
+
+The release adds a small wobble. Our model uses a common starting point for it even though the captures show slightly different onset times across gesture types. That approximation is one reason to keep the full gesture suite alongside the short demo.
+
+## Keep icons legible as the backdrop changes
+
+A vibrant tab icon is not simply painted with an alpha color. Its result depends on the glass behind it. The probe reads UIKit's color matrices across tint sweeps, and `VibrancyMatrix` reconstructs the transform.
+
+For a non-gray dark tint vector `t`, the measured form is:
+
+```text
+e = 0.5 * min(t) / max(t)
+M = e*I + (0.5 - e) * (ones * transpose(t)) / dot(t,t)
+offset = t
+output = M * backdrop + offset
+```
+
+`I` is the identity matrix and `ones` is a column of three ones. Gray tints have their own formula, so this expression is not a universal branch to paste over the implementation. Light appearance uses a different form. The [vibrancy source](https://github.com/codenameone/CodenameOne/blob/master/CodenameOne/src/com/codename1/ui/plaf/VibrancyMatrix.java) and recorded fixture hold those cases together.
+
+The selection platter also transforms the bar's existing glass. `Graphics.colorMatrixRegion` applies that operation within a shape and optional mask. The lifted lens needs a separate operation: refraction around a circular bevel, color dispersion, an outline, rim light and shadow. `glassLensRegion` supplies that rendering path.
+
+This is why adjusting the opacity of a rounded rectangle could only take us so far. The effect changes the content underneath it.
+
+## Keep the glass animation on the GPU
+
+A more accurate motion model is wasted if the renderer misses the frames that distinguish it. The iOS bar glass now runs on the GPU instead of passing through a CPU blur with GPU synchronization around it. Mutable images reuse their stencil texture. The tab animation avoids asking for a second whole-component repaint, and the lens scratch texture is released after use.
+
+The portable color-matrix operation reaches the JavaScript port too. The browser lens still lacks the full optics implementation. A shared API does not mean every rendering backend implements every effect today.
+
+## Choose the appearance, then test your screen
+
+In the Settings app's **Build Hints**, select:
+
+```properties
+ios.themeMode=modern
+ios.themeGeneration=27
+```
+
+For the cloud toolchain, `ios.xcode_version=27` is a separate setting. In `codenameone_settings.properties`, prefix build-hint keys with `codename1.arg.`. A local Xcode build uses the Xcode installation selected on your Mac.
+
+Codename One draws these controls itself. The theme and its motion ship with the app, so adopting this appearance remains your decision. That control also gives us the responsibility to measure the behavior we reproduce.
+
+Try the animation over a photograph, a scrolling list and a plain dark background. Hold it. Drag past the middle and release. The [implementation in PR #5906](https://github.com/codenameone/CodenameOne/pull/5906) and the fixtures behind it make those interactions repeatable instead of leaving fidelity to memory.
+
+---
+
+## Discussion
+
+_Which gesture exposes an animation that looked right in a screenshot?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/java-server-work-before-startup.md b/docs/website/content/blog/java-server-work-before-startup.md
new file mode 100644
index 00000000000..fe50dc6fb2d
--- /dev/null
+++ b/docs/website/content/blog/java-server-work-before-startup.md
@@ -0,0 +1,429 @@
+---
+title: "A Smaller, Faster Java Server with a Spring-Style API"
+slug: java-server-work-before-startup
+url: /blog/java-server-work-before-startup/
+date: '2026-10-02'
+author: Shai Almog
+description: "Build a smaller native Java service with Spring-style transactions and dependency injection. Inspect the generated code and compare local Linux startup, memory, throughput, binary size and build time."
+feed_html: '
Build a smaller native Java service with Spring-style transactions and dependency injection. Inspect the generated code and compare local Linux startup, memory, throughput, binary size and build time.'
+series: ["release-2026-10-02"]
+---
+
+
+
+What do you pay for Spring and Java's dynamic architecture? Can you deliver the same API without the same runtime cost?
+
+For a small service, you might want dependency injection, transactions and scheduled jobs without a long startup or a large deployment. That is the case our native Java backend is trying to make. Write a controller and a service, compile their wiring into the application, then deploy a native executable.
+
+In the two-core Linux HTTP test below, the CN1 executable occupies `5.17 MiB` and reaches its first verified response in `14.8 ms`. The same two endpoints in Spring/GraalVM occupy `88.31 MiB` and respond in `43.6 ms`. That is the sort of difference worth investigating for a small service.
+
+This week's Spring-style API adds the parts that make that approach useful beyond a greeting endpoint: transaction propagation, scoped beans, background tasks, sessions, metrics and MCP tools. ParparVM supplies the native runtime, including virtual threads that can park while a handler waits for PostgreSQL, MySQL or another HTTP service.
+
+**This is a Spring-style API, not a drop-in Spring implementation.** Its annotations live in `com.codename1.backend.annotations`. Spring itself supports AOT processing and GraalVM Native Image. Our proposition is a smaller supported surface with direct generated calls, a native runtime shared with our app framework, and code you can inspect when you want to know what an annotation costs.
+
+The backend is still a work in progress. It sits on ParparVM, the runtime behind our native iOS apps, and is maturing rapidly. The local measurements below show where it earns the “smaller, faster” description. They also define the narrow workload being compared.
+
+## Coming This Week
+
+Today's article covers the backend API, generated code and local server comparison. The follow-ups explore what you can do with the rest of the release:
+
+- **Saturday, October 3:** {{< post-link path="/blog/parparvm-four-byte-header" text="Honey, I Shrunk Java" >}}. How object headers, compiler optimizations and garbage collection affect the memory and CPU your application needs.
+- **Sunday, October 4:** {{< post-link path="/blog/ios27-glass-from-measurements" text="Can You Tell the Difference Between These iOS Tab Bars?" >}}. Compare the videos, then see how measured motion and glass formulas make your UI feel closer to UIKit.
+- **Monday, October 5:** {{< post-link path="/blog/gradle-smaller-projects" text="Do You Prefer Gradle?" >}}. Start with fewer files, build a standalone backend, find the right Javadocs, and try the separate Android Gradle 9 option.
+- **Tuesday, October 6:** {{< post-link path="/blog/native-backend-observability" text="Connect Your App to Your Enterprise Traces" >}}. Connect your client app and native backend to traces across your enterprise services, with metrics and MCP alongside them.
+- **Wednesday, October 7:** {{< post-link path="/blog/browser-desktop-theme" text="Do You Want Your Web App to Feel Like a Native App?" >}}. Use desktop themes and visible menus in the browser. The Certificate Wizard gets the same theme families.
+- **Thursday, October 8:** {{< post-link path="/blog/friday-release-better-gates" text="Don't Order Fish on Monday. Don't Release on Friday" >}}. Catch private API imports before submission, and what a difficult Friday release taught us about gaps in testing.
+
+## Compare startup, memory, throughput and build time
+
+The measurements use CN1 revision [`60c4f310`](https://github.com/codenameone/CodenameOne/tree/60c4f310bddcfc51e5acc75c63a57c43c73430d3). For the comparison, we ran two small HTTP handlers on the Linux deployment target: a 13-byte plaintext response and a JSON object containing one `message` field. The CN1 executable uses the repository's lower-level `Bench` handler. Spring Boot 4.1.1 uses Spring MVC and embedded Tomcat, running either on Temurin JDK 25 or as a GraalVM 25 native executable.
+
+**This compares the selected HTTP stacks, not equivalent framework features.** The CN1 handler does not exercise the annotation-generated application shown below. There is no database, TLS, authentication, or telemetry in either application. Both JSON handlers create a map per request; CN1 also allocates a fresh response object.
+
+The host is an Apple M4 Max with 16 logical CPUs and `64 GiB` RAM. The local Linux ARM64 VM has four virtual CPUs and `8 GiB`. Linux CPU affinity restricts the server to 1, 2, or 4 CPUs. At 1 and 2, the load generator runs on the remaining CPUs; at 4, it shares them with the server. These are actual scheduling restrictions, not just a reported processor count.
+
+### Start quickly and ship a smaller executable
+
+The two-core configuration gives the server and load generator separate CPUs. Here are medians from three fresh processes, with the startup range in parentheses:
+
+| Application | First response, ms: median (range), lower is better | Native executable, MiB, lower is better |
+| --- | ---: | ---: |
+| CN1 native | 14.8 (5.3-15.1) | 5.17 |
+| Spring Boot / JDK 25 | 1,501.1 (1,407.6-1,617.8) | N/A |
+| Spring Boot / GraalVM 25 | 43.6 (32.5-45.6) | 88.31 |
+
+[](/blog/native-http-charts/startup.png)
+
+Startup includes spawning the process and receiving a verified HTTP response. File system caches are left warm; this is not a cold-machine or serverless measurement. The polling loop and `taskset` launcher also contribute to the short native times. The JVM run uses its default runtime settings without an AOT cache.
+
+[](/blog/native-http-charts/binary-size.png)
+
+The CN1 executable is `5.17 MiB`, compared with `88.31 MiB` for this Spring native build. These are uncompressed executable files from the default build outputs. Both files were unchanged by an additional pass that strips symbols. Both builds use shared system libraries, which are excluded here. This is not a container-size or complete-deployment comparison. The JVM column is N/A because its JAR is not a standalone native executable.
+
+### Leave more memory for the work your service does
+
+A server's memory use changes after it starts accepting traffic. We recorded all three stages using the same windows for each runtime:
+
+| Application, 2 allowed CPUs | Idle before load, MiB | Peak through load, MiB | Idle after load, MiB |
+| --- | ---: | ---: | ---: |
+| CN1 native | 10.0 | 57.8 | 29.8 |
+| Spring Boot / JDK 25 | 163.0 | 282.2 | 282.3 |
+| Spring Boot / GraalVM 25 | 78.1 | 117.0 | 79.6 |
+
+[](/blog/native-http-charts/memory.png)
+
+*Lower is better in all three memory columns. Idle before load is sampled three seconds after the first verified response. Peak is the kernel's resident-memory high-water mark through startup and both routes. Idle after load is sampled five seconds after traffic ends, without forcing collection. Each table entry is the median of the three process measurements.*
+
+CN1 uses less resident memory in both the idle and loaded measurements here. Four-byte object metadata is only one part of that cost. RSS also includes code, stacks, allocator pages and library state; it is not the live Java heap. This Linux build uses native virtual threads, so its connection costs differ from a platform-thread pool.
+
+### Serve requests with 1, 2 or 4 CPUs
+
+| Allowed server CPUs | Application | Plaintext requests/s | JSON requests/s |
+| --- | --- | ---: | ---: |
+| 1 | CN1 native | 164,542 | 138,555 |
+| 1 | Spring Boot / JDK 25 | 34,721 | 64,068 |
+| 1 | Spring Boot / GraalVM 25 | 40,286 | 39,167 |
+| 2 | CN1 native | 287,997 | 261,121 |
+| 2 | Spring Boot / JDK 25 | 69,953 | 70,491 |
+| 2 | Spring Boot / GraalVM 25 | 51,729 | 49,000 |
+| 4 | CN1 native | 245,608 | 251,435 |
+| 4 | Spring Boot / JDK 25 | 116,491 | 110,530 |
+| 4 | Spring Boot / GraalVM 25 | 80,053 | 61,873 |
+
+[](/blog/native-http-charts/throughput.png)
+
+*Higher is better. Points are medians; whiskers show the three-run range. Each route has ten seconds of warmup and ten seconds of measurement, using two `wrk` threads and 32 connections. Plaintext precedes JSON. Four-core points include load-generator contention, so this is not a clean four-core scaling curve.*
+
+### Does HotSpot catch up after warmup?
+
+CN1 still leads after a minute of warmup per endpoint: **3.9 times the plaintext throughput and 3.4 times the JSON throughput** of Spring/JDK 25 in the matched two-core follow-up. Both servers received the same longer warmup, followed by three consecutive ten-second measurement windows for each route.
+
+| Application, 2 allowed CPUs | Plaintext requests/s | JSON requests/s |
+| --- | ---: | ---: |
+| CN1 native, 60 s warmup per route | 296,928 | 250,268 |
+| Spring Boot / JDK 25, 60 s warmup per route | 75,721 | 73,613 |
+
+[](/blog/native-http-charts/warmed-throughput.png)
+
+*Higher is better. These are medians of three windows within one fresh process per runtime, separate from the three-process matrix above. The server uses CPUs 0 and 1; `wrk` uses CPUs 2 and 3, with 32 connections. Both routes completed without socket or non-2xx errors.*
+
+We checked HotSpot's compiled-method list during warmup: Spring's request dispatcher and handler adapter had reached tier-4 compilation. The snapshot is included in the reproduction bundle. The extra warmup does not close the gap for these two handlers. More complex application code, dependencies and different concurrency levels can change that comparison.
+
+The matrix rotates runtime order and reverses CPU order in its middle round. Every response body is checked before load; any socket or non-2xx error during warmup or measurement rejects the run. All 27 process runs completed without those errors. Keep-alive request limits are raised or disabled on both servers; other runtime settings use their defaults.
+
+### How long do you wait for a build?
+
+Native compilation moves work out of startup and into the build. You do not need to pay that cost after every edit: CN1's debug/development mode runs on the JVM, while the native build produces the deployment executable.
+
+| Build | Median elapsed, seconds | Three-run range, seconds |
+| --- | ---: | ---: |
+| Spring Boot / JDK 25 | 2.07 | 1.54-2.57 |
+| CN1 debug / JVM | 1.67 | 1.57-2.49 |
+| CN1 native | 95.34 | 75.43-107.08 |
+| Spring Boot / GraalVM 25 | 200.89 | 174.80-214.39 |
+
+[](/blog/native-http-charts/build-time.png)
+
+*Lower is better. Three builds per configuration, with runtime order rotated, on the same four-vCPU, `8 GiB` Linux VM. Application outputs are rebuilt each time; dependencies and toolchains are cached. Downloads, tests and server startup are excluded.*
+
+For this example, the CN1 native build takes **53% less elapsed time** than Spring/GraalVM. The JVM builds take seconds. That keeps the edit-and-debug loop short while letting you check the native artifact before deployment.
+
+The CN1 development measurement compiles the repository's `Bench` handler, JavaSE backend runtime and shared sources with JDK 25. The native path compiles Java with JDK 8, translates it, then compiles and links the generated C with Clang at `-O3`; the translator and Java API dependencies are prebuilt. Spring uses Maven `clean package` on JDK 25; its native build adds Spring AOT processing and GraalVM `native:compile`. These are build-path timings for the HTTP examples, including their different build tools, rather than isolated `javac` or incremental-build timings.
+
+The [reproduction bundle](/blog/native-http-comparison.zip) includes sources, commands, artifact hashes, every raw sample, the matched longer-warmup comparison, clean-output build timings, and the generated Java example. The results make a small native backend worth trying for services with these constraints. Measure your own handlers and dependencies before using them to choose deployment capacity.
+
+## Start your service with less runtime setup
+
+Here is a complete controller for a backend module:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.GetMapping;
+import com.codename1.backend.annotations.RestController;
+
+@RestController
+public class GreetingApi {
+ @GetMapping("/hello")
+ public String hello() {
+ return "Hello, World!";
+ }
+}
+```
+
+After `javac` compiles your sources, the build reads the annotations and generates Java classes for routing, dependency injection and method instrumentation. ParparVM translates the resulting bytecode to C, then the native compiler builds the executable.
+
+[](/developer-guide/img/backend-build-pipeline.svg)
+
+*From the current Backend guide. The generated classes are ordinary input to the translator and its dead-code analysis.*
+
+A generated `Router` holds the route as bytes and binds parameters according to their declared types. `BackendWiring` creates beans in dependency order. Missing dependencies, ambiguous candidates, constructor cycles and duplicate routes fail the build with the relevant class or injection point.
+
+Here is an excerpt of the wiring generated for this controller and the `Notes` service in the next section. Only line wrapping and the surrounding method have been omitted:
+
+```java
+b_greetingApi = new example.GreetingApi();
+b_notes = new example.Notes(
+ com.codename1.backend.Backend.requireDataSource(
+ dataSource, "constructor parameter 1 of example.Notes"));
+```
+
+There is no runtime search for a `Notes` constructor or a matching database bean. The call is in the generated program. With more dependencies, the build orders the constructor calls and emits field or setter injection afterward. A private `@Autowired` field gets a generated setter so the assignment can still be a direct call.
+
+This gives you a useful debugging option: follow the call into the generated code and see exactly what it constructs. It also lets the native linker remove unreferenced classes. You exchange some of Spring's runtime flexibility for a build that can resolve more of the application before deployment.
+
+## Keep your transaction when you call another method
+
+If you use Spring's usual proxy-based transactions, a call through `this` bypasses the proxy. That can make a refactor change transactional behavior even though the annotation is still on the method. Spring documents both the limitation and its bytecode-weaving alternative in the [proxying guide](https://docs.spring.io/spring-framework/reference/core/aop/proxying.html).
+
+Our build rewrites the annotated method itself. `@Transactional`, `@Async`, `@Timed` and `@Counted` therefore apply when another method on the same object calls it. They also apply to private methods and project classes you construct with `new`.
+
+For example, this service writes a note and an audit row in one transaction. Assume migrations have created `note(body)` and `audit(message)` in the configured database:
+
+```java
+package example;
+
+import com.codename1.backend.DataSource;
+import com.codename1.backend.annotations.Component;
+import com.codename1.backend.annotations.Transactional;
+import java.io.IOException;
+
+@Component
+public class Notes {
+ private final DataSource db;
+
+ public Notes(DataSource db) {
+ this.db = db;
+ }
+
+ @Transactional(rollbackFor = IOException.class)
+ public void add(String body) throws IOException {
+ db.execute("INSERT INTO note (body) VALUES (?)", new Object[] {body});
+ db.execute("INSERT INTO audit (message) VALUES (?)",
+ new Object[] {"note created"});
+ }
+}
+```
+
+What does the annotation become? We ran this class through the current processor. It moves the original body into `add$cn1body_Notes` and makes `add` delegate to this generated helper. Package qualifiers are shortened below and line breaks added for readability; the control flow and rollback expression are the generated output:
+
+```java
+static void add(example.Notes self, java.lang.String a0) throws Throwable {
+ Object cn1Tx = BackendAccess.get().begin(BackendAccess.REQUIRED, false, -1);
+ try {
+ self.add$cn1body_Notes(a0);
+ } catch (Throwable cn1Error) {
+ BackendAccess.get().afterThrow(cn1Tx,
+ cn1Error instanceof java.io.IOException ? true :
+ (cn1Error instanceof java.lang.RuntimeException
+ || cn1Error instanceof java.lang.Error
+ || cn1Error instanceof DataAccessException));
+ throw cn1Error;
+ }
+ BackendAccess.get().commit(cn1Tx);
+}
+```
+
+`BackendAccess` is an internal bridge used by generated code. Your service uses `@Transactional`; it does not call that bridge itself. The body runs inside a transaction boundary regardless of how you reached `add`. The generated helper asks the transaction manager to complete or roll back the appropriate boundary, then propagates a failure. There is no runtime annotation lookup or proxy dispatch for this method. The [processor source](https://github.com/codenameone/CodenameOne/blob/3d2db4eee774cf7d0d0a18fc3100d005ce108897/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/processors/BackendSources.java) and [bytecode weaver](https://github.com/codenameone/CodenameOne/blob/3d2db4eee774cf7d0d0a18fc3100d005ce108897/maven/codenameone-maven-plugin/src/main/java/com/codename1/maven/processors/BackendWeaver.java) show both halves.
+
+The database connection is borrowed lazily, at the first database operation. The method can return without touching the pool if it never accesses the database. `DataSource`, generated DAOs and managed ORM sessions join the transaction associated with the executing thread.
+
+[](/developer-guide/img/backend-transaction-propagation.svg)
+
+You can choose all seven propagation modes: `REQUIRED`, `REQUIRES_NEW`, `NESTED`, `SUPPORTS`, `MANDATORY`, `NOT_SUPPORTED` and `NEVER`. The important choices are what you want to happen when a transaction exists, and whether an inner failure should undo the outer work. `REQUIRES_NEW` needs another connection; `NESTED` uses a savepoint on the current one.
+
+Read-only declarations, timeouts and explicit rollback rules are supported. Isolation-level selection is not. An asynchronous task does not inherit its caller's transaction, and a database transaction cannot undo an email or an HTTP request. The [data chapter](/developer-guide/backend-data/) spells out these boundaries, including what happens when code touches more than one connection pool.
+
+## Handle more waiting requests without a thread per connection
+
+If your handler spends most of its time waiting for another server, an OS thread per connection is expensive. You want straightforward blocking code without making each wait occupy a host thread.
+
+On the Linux native HTTP path, each connection has a ParparVM virtual thread: a stack retained for the life of that connection. Host threads run those stacks. A host owns its connections and their `epoll` registrations; a virtual thread stays with that host. When the handler needs bytes that have not arrived, the runtime parks its stack and lets the host run another connection.
+
+[](/developer-guide/img/backend-architecture.svg)
+
+That applies beyond the incoming socket. PostgreSQL and MySQL queries use the same parking mechanism. Outbound HTTP, including its TLS handshake, can park too. Your service can wait for a query in ordinary sequential Java while other connections continue on the same host.
+
+{{< mermaid >}}
+sequenceDiagram
+ participant A as Request A
+ participant H as Host thread
+ participant DB as Database socket
+ participant B as Request B
+ H->>A: Resume handler
+ A->>DB: Send query
+ A-->>H: Park until socket is ready
+ H->>B: Run another handler
+ B-->>H: Finish response or park
+ DB-->>H: epoll reports readable socket
+ H->>A: Resume at the waiting call
+{{< /mermaid >}}
+
+Background tasks now participate in this model too. A virtual task has no incoming connection descriptor, so the host uses a wake pipe to notice newly submitted work. `Future.get()` on a virtual thread yields cooperatively while waiting for the task. Blocking the host there could otherwise stall the very task whose result the handler needs.
+
+This work also fixed a subtle scheduler failure: each yield site must report whether it is runnable or waiting for I/O. A stale reason could leave a handler stuck after `yieldNow()` or send an I/O wait back through the runnable path after garbage-collector backpressure. A virtual-thread API is only useful when those transitions remain correct under load.
+
+You still need to choose the right executor for your work:
+
+| Your operation | Native virtual-thread behavior | Practical choice |
+| --- | --- | --- |
+| Wait for PostgreSQL, MySQL or outbound HTTP | Parks at supported socket waits | Virtual threads suit this work |
+| Wait on an asynchronous task's `Future` | Yields cooperatively | A virtual handler can await virtual work |
+| SQLite, file access, DNS resolution or `Object.wait()` | Can block the host thread | Put blocking local work on a platform executor |
+| Incoming TLS server connection | Uses the platform-thread pool | Account for pool capacity |
+| JVM development run | Uses platform threads, including `VIRTUAL` tasks | Test native concurrency before deployment |
+
+These are ParparVM's virtual threads, not the JDK implementation. `ThreadKind.PLATFORM` remains the default for `@Async` and `@Scheduled`; `VIRTUAL` requests the native facility where available, and `AUTO` selects it when the server has virtual hosts. The [scheduling chapter](/developer-guide/backend-scheduling/) documents fallback behavior and named executors.
+
+## Schedule work without accidental duplicate runs
+
+A scheduled method runs outside the request thread. Use a fixed rate when you want starts at regular intervals, or a fixed delay when you want a pause after the previous run finishes. The distinction becomes visible as soon as the job takes longer than expected:
+
+[](/developer-guide/img/backend-schedule-timelines.svg)
+
+One job does not overlap itself within a process. If a fixed-rate job is still running at its next start, that start is skipped. The build validates the method signature and six-field cron expressions; configuration can supply the actual schedule.
+
+When you deploy several server instances, each instance has a scheduler. A database lock lets them coordinate one job across replicas. For example, `@Scheduled(fixedDelay = 60000, lock = "purge")` requests a shared lock. The lease must exceed the job's maximum runtime, since expiry permits another instance to claim it. You can inspect job state and skipped runs through the management endpoints.
+
+## Keep configuration and state explicit as your service grows
+
+The Spring-style surface extends beyond the three annotations in a demo:
+
+| What you need | API and behavior |
+| --- | --- |
+| Select an implementation | `@Primary` and `@Qualifier` resolve competing dependencies |
+| Bind deployment settings | `@Value` and `@ConfigurationProperties` bind configuration |
+| Enable an environment-specific bean | `@Profile` and `@ConditionalOnProperty` control activation |
+| Construct a library object | A `@Bean` factory supplies it explicitly |
+| Keep state for one request or session | `@Scope("request")` and `@Scope("session")` locate the current instance through generated stand-ins |
+| Initialize and shut down resources | `@PostConstruct` and `@PreDestroy` hooks participate in lifecycle management |
+| Measure or manage a service method | `@Timed`, `@Counted`, `@ManagedResource` and related annotations generate adapters |
+
+The build catches unresolved wiring, but runtime configuration can still deactivate a required bean or omit a necessary value. Request, session and lazy stand-ins need a non-final class and an accessible no-argument constructor. That constructor runs for the stand-in too. The [beans chapter](/developer-guide/backend-beans/) explains the supported combinations and their restrictions.
+
+Sessions use an in-memory or database store. They are created on demand, so an API that never asks for a session does not set a session cookie. Rotate the identifier at sign-in with `changeSessionId()`, and use the database store when multiple instances need to share session state. Session-scoped destruction on expiry remains a documented limitation.
+
+[](/developer-guide/img/backend-session-lifecycle.svg)
+
+There is no general `ApplicationContext` lookup, and an arbitrary JAR on the classpath does not become a compatible Spring bean library. Native backend sources currently use Java 8 language level against the supported runtime library. Packaged deployment targets Linux. Those boundaries help you decide whether a small service fits this backend before attempting a migration.
+
+## Keep your service visible across your enterprise
+
+An order can cross a client app, your native backend and several existing services. The backend can continue the incoming trace and propagate it on outbound HTTP calls so your operations team can follow that work in its existing observability system. Optional OpenTelemetry tracing and metrics are compiled into the executable, alongside management endpoints for health, jobs and application resources.
+
+The generated server has a defined request chain. Its own endpoints run before application routes, and static files come last. A wrapper handles request scope, session persistence and request metrics:
+
+[](/developer-guide/img/backend-request-lifecycle.svg)
+
+MCP gives your development tools a way to inspect the running service. An agent can list routes and beans, call an endpoint, inspect recent requests, and query database state through the development tools. You can publish application tools with `@McpTool`; the build generates their argument schemas and direct dispatch.
+
+Development tools are excluded from packaged servers by default. A production MCP endpoint requires a token. Tuesday's article connects the client and backend to an enterprise trace, then covers metrics and the MCP development workflow.
+
+To try the backend, start with the [backend guide](/developer-guide/backend/) and a small endpoint, then add a database operation and verify its rollback behavior. The implementation behind [PR #5908](https://github.com/codenameone/CodenameOne/pull/5908) is the basis for this week's expanded API.
+
+---
+
+## More This Week
+
+That is the backend story. The rest of the release reaches your app's UI, project structure and submission process. Here is a closer look at each upcoming post, plus a small maps improvement.
+
+### How your Java server uses less RAM
+
+**Saturday: {{< post-link path="/blog/parparvm-four-byte-header" text="Honey, I Shrunk Java" >}}**
+
+The server comparison above puts CN1's peak RSS at **`57.8 MiB`**, against **`117.0 MiB`** for Spring/GraalVM. Saturday explains the runtime work behind that smaller footprint: four-byte object headers, tighter fields, fewer temporary objects and changes to garbage collection. We will also look at the compiler translating itself faster than JDK 25, and explain how ParparVM's layout differs from HotSpot's compact headers and Leyden's AOT work. Headers are part of the saving; the whole server measurement includes code, stacks and libraries too.
+
+### Can your users spot the custom-rendered tab bar?
+
+**Sunday: {{< post-link path="/blog/ios27-glass-from-measurements" text="Can You Tell the Difference Between These iOS Tab Bars?" >}}**
+
+[Last week's iOS 27 theme](/blog/ios-27-glass-you-can-test/) still had motion I wasn't happy with. This comparison shows the refinement under taps, holds, and drags. Watch the original video; the small changes in timing and glass detail are the point.
+
+{{< guide-block >}}
+
+{{< /guide-block >}}
+
+*UIKit is above Codename One in this side-by-side simulator recording.*
+
+Sunday's post follows the reverse engineering from frame measurements to spring equations, vibrancy and lens rendering. You can judge the remaining differences and choose when to adopt the theme in your app.
+
+### Choose Gradle and start with fewer files
+
+**Monday: {{< post-link path="/blog/gradle-smaller-projects" text="Do You Prefer Gradle?" >}}**
+
+You can now start a smaller Gradle project and add platform directories when needed. A standalone backend no longer requires a client project alongside it. That makes the tree easier to navigate and leaves less boilerplate in an LLM's context. I still prefer Maven XML, for reasons involving the `make` files I lived with at Sun, but your preference should not block either project shape.
+
+
+We converted the repository's HelloCodenameOne sample: **358 files became 305**, and **nine POMs became two Gradle Kotlin files**. That is 53 fewer files around the same application. The count includes sources and resources, excludes generated build output, and comes from the actual converter.
+
+The generated `settings.gradle.kts` selects the build plugin:
+
+```kotlin
+plugins {
+ id("com.codenameone") version "8.0-SNAPSHOT"
+}
+rootProject.name = "HelloCodenameOne"
+```
+
+This is an excerpt; the generated file also configures plugin repositories. Use the release version containing Gradle support when it is published. Monday shows the full setup and conversion commands.
+
+The new [backend Javadocs](/backend/javadoc/) also separate server APIs from the [client reference](/javadoc/), with shared classes identified between them. Monday covers that split and the separate, experimental Gradle 9 Android build option. Choosing Gradle for your project and changing the Android builder's Gradle version are independent choices.
+
+### Bring your app into your enterprise traces
+
+**Tuesday: {{< post-link path="/blog/native-backend-observability" text="Connect Your App to Your Enterprise Traces" >}}**
+
+Your mobile or web app can be the start of a trace that crosses a native CN1 backend, existing Java services and a database. The client and server propagate the same trace context, so compiling the backend to native code need not leave a gap in your enterprise observability. You can use your existing OTel collector and tracing system, with collector credentials kept on the server.
+
+{{< mermaid >}}
+flowchart LR
+ App[CN1 client app] -->|traceparent| Native[CN1 native backend]
+ Native -->|traceparent| Java[Existing Java service]
+ Java --> DB[(Database)]
+ App -. app spans via relay .-> Collector[Enterprise OTel collector]
+ Native -. spans and metrics .-> Collector
+ Java -. service telemetry .-> Collector
+{{< /mermaid >}}
+
+Tuesday explains the setup, sampling and metric labels that keep telemetry manageable as traffic grows, plus MCP tools for checking the service during development. Downstream services must participate in trace propagation too.
+
+### Make your browser app feel like a native desktop app
+
+**Wednesday: {{< post-link path="/blog/browser-desktop-theme" text="Do You Want Your Web App to Feel Like a Native App?" >}}**
+
+Your web app can now use native desktop OS styling: macOS (Aqua), Windows (Fluent) or Linux (Adwaita). An optional HTML title and menu bar puts commands above the application. Additional OS windows remain unsupported in the JavaScript port because of browser popup restrictions; that does not exclude Windows browsers. The Certificate Wizard adopts the same desktop theme families, continuing last week's Settings work.
+
+[](/blog/desktop-theme-collage.jpg)
+
+*The Settings app shows the three desktop theme families now available in the JavaScript port.*
+
+### Read street names along the road
+
+There is a smaller maps improvement too: names now follow the road geometry, with curved glyph placement on bends and upright text along straighter sections. Labels remain above route overlays, so the route does not hide the street you need to follow.
+
+
+
+*From the Maps guide. The renderer rejects placements that bend too sharply or collide with other labels.*
+
+This is part of the continuing vector-map work in [PR #5902](https://github.com/codenameone/CodenameOne/pull/5902). The [Maps guide](/developer-guide/maps/) covers the renderer and deeper zooming without stretching raster tiles.
+
+### Your release also has to survive submission
+
+**Thursday: {{< post-link path="/blog/friday-release-better-gates" text="Don't Order Fish on Monday. Don't Release on Friday" >}}**
+
+A working simulator or device build can still import an API that Apple rejects at submission. In this case, the unwanted imports appeared only when particular optional APIs were enabled, so most apps and our usual test configuration missed them. The new check looks for imported SDK symbols without public declarations, exercises optional feature combinations and inspects a linked Release device app. It catches a class of mistake that another happy-path test would miss.
+
+This was a rough week of regressions around the optional Xcode 27 path, push, and windows. Some overlapped, so we thought we had fixed a bug only to discover its symptoms had moved. Thursday's post explains one of those failures, why we release on Friday despite the obvious cost to our weekends, and how better gates can protect your release from ours. The Apple check has a defined scope; it cannot guarantee App Store acceptance.
+
+There is a lot to try this week. There is also work to do on the reliability of getting it into your hands. I would like you to spend the next release testing something useful in your app, rather than helping us untangle a regression. That is why the gate work matters as much as the new features.
+
+---
+
+## Discussion
+
+_What would you need to see before trying a smaller native Java backend for one of your services?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/native-backend-observability.md b/docs/website/content/blog/native-backend-observability.md
new file mode 100644
index 00000000000..d6aedc6db06
--- /dev/null
+++ b/docs/website/content/blog/native-backend-observability.md
@@ -0,0 +1,210 @@
+---
+title: "Connect Your App to Your Enterprise Traces"
+slug: native-backend-observability
+url: /blog/native-backend-observability/
+date: '2026-10-06'
+author: Shai Almog
+description: "Connect your client app and native Java backend to distributed enterprise traces, export metrics through OpenTelemetry, and keep collector credentials on the server."
+feed_html: '
Connect your client app and native Java backend to distributed enterprise traces, export metrics through OpenTelemetry, and keep collector credentials on the server.'
+series: ["release-2026-10-02"]
+---
+
+
+
+Your customer taps “Place order.” The request crosses your app, an API gateway, a native backend, a payment service and a database. Your operations team needs to see that path in the same tracing system it uses for the rest of the company. Neither the client app nor a compiled Java server should disappear from that picture.
+
+I wrote a book on debugging, so I am probably more opinionated about this than most people: in 2026, production diagnosis should not depend on somebody searching a pile of logs with `grep` and guessing which lines belong together.
+
+Logs still matter. At enterprise scale, though, you need to connect work across machines, teams and runtimes, then see whether a failure is isolated or spreading. On a JVM, Java agents can instrument much of that work for us. Once our backend is translated to C and compiled into a native executable, the usual JVM instrumentation hook is gone.
+
+We have to carry that visibility into the binary. [OpenTelemetry support](/blog/follow-a-tap-with-opentelemetry/) started that work last week. The [expanded backend API](https://github.com/codenameone/CodenameOne/pull/5908) adds metrics and management alongside it. This article follows what happens after you turn them on.
+
+## Follow an operation across your systems
+
+Observability is the ability to understand a system's internal behavior from the evidence it emits. OpenTelemetry, usually shortened to OTel, defines APIs, data conventions and transport for producing that evidence. It is not itself the screen where you investigate an incident; a collector and an observability backend handle that part. The [OTel primer](https://opentelemetry.io/docs/concepts/observability-primer/) provides the broader model.
+
+| Question | Useful evidence |
+| --- | --- |
+| Why did this request take two seconds? | A trace connecting its operations |
+| Is database waiting increasing across the service? | Metrics over time |
+| What did the application decide at the failure? | Logs and events with context |
+
+A span records one timed operation. Related spans form a trace. Metrics aggregate behavior across operations: a count, a current value or a distribution such as request duration. Neither replaces the other. A single trace can explain a slow query without telling you how often it occurs.
+
+Our integration exports traces and metrics. It does not turn every application log into an OTLP log record.
+
+## Add tracing to your native executable
+
+Put this in the backend's `application.properties` before building:
+
+```properties
+cn1.otel.enabled=true
+```
+
+Or use the backend's `@OpenTelemetry` annotation. The generator installs the tracer, making its implementation reachable to the translator. Without that build-time opt-in, the unused tracing code can be left out. Setting an environment variable after deploying a binary that omitted the tracer cannot add it back.
+
+Once enabled, the runtime records an incoming request span named for its route template. A `Web` call creates a client span and propagates W3C trace headers. A database statement creates another client span. Incoming `traceparent` connects the request to its caller.
+
+{{< mermaid >}}
+sequenceDiagram
+ participant App as CN1 client app
+ participant Native as CN1 native backend
+ participant Service as Existing enterprise service
+ participant DB as Database
+ participant Collector as Enterprise OTel collector
+ App->>Native: Order request + traceparent
+ Native->>Service: HTTP call + traceparent
+ Service->>DB: SQL span under the same trace
+ DB-->>Service: Result
+ Service-->>Native: Result
+ Native-->>App: Response
+ App->>Native: Batched client spans via relay
+ Native->>Collector: Client spans + server spans + metrics
+ Service->>Collector: Existing service telemetry
+{{< /mermaid >}}
+
+The native backend propagates context on outbound `Web` calls. Each receiving service must accept and continue that context. OTel-compatible instrumentation lets those services participate regardless of their implementation language.
+
+## Include the client, not just the servers
+
+The client annotation belongs on your app's main class:
+
+```java
+import com.codename1.annotations.OpenTelemetry;
+import com.codename1.system.Lifecycle;
+
+@OpenTelemetry(
+ relay = "https://api.example.com",
+ serviceName = "orders-app",
+ sampleRatio = 0.2,
+ requireAnalyticsConsent = true)
+public class OrdersApp extends Lifecycle {
+}
+```
+
+Replace the URL with your backend. Enable its relay as shown below, and wire the app's analytics-consent flow before collecting telemetry. The client instruments supported app operations and `ConnectionRequest` calls, including outgoing trace context. It sends its recorded spans through the backend rather than carrying your collector credentials.
+
+For browser apps, context propagation is limited to the relay host and configured `propagateTo` hosts. A cross-origin service must allow the tracing headers in CORS. The [client tracing walkthrough](/blog/follow-a-tap-with-opentelemetry/) covers consent, propagation and the supported span types.
+
+That connects the experience on the device to the work behind it. A server-only trace cannot show the client work before the request or after the response. You can investigate that larger path in your enterprise tracing system instead of keeping a separate, disconnected account of what the app did.
+
+
+Database spans record SQL as supplied, with placeholders intact; bound parameters are not recorded. If an application concatenates a secret into SQL, the resulting text already contains it. `cn1.otel.attributes.exclude=db.query.text` can exclude that attribute. Parameterized SQL remains the better habit.
+
+WebSocket lifetime is outside this automatic request-span model. An hours-long connection with thousands of messages is not one useful HTTP request duration, and its upgrade is handled before this tracing path.
+
+## Send it to the system your team already uses
+
+For an enabled build, configure a collector at runtime:
+
+```bash
+export OTEL_SERVICE_NAME=orders-native
+export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318
+export OTEL_TRACES_SAMPLER=parentbased_traceidratio
+export OTEL_TRACES_SAMPLER_ARG=0.1
+./build/Orders
+```
+
+Here `Orders` is the packaged application's executable. The ratio samples a tenth of newly rooted traces; the parent-based policy respects an upstream sampling decision.
+
+The exporter uses OTLP over HTTP, with protobuf by default and JSON as an option. It does not implement OTLP/gRPC. It appends `/v1/traces` or `/v1/metrics` to the base endpoint unless you supply a signal-specific endpoint.
+
+Dynatrace can receive that OTLP data. For traces, its [documented ingest endpoint](https://docs.dynatrace.com/docs/ingest-from/opentelemetry/otlp-api) is configured through `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, with an ingest credential in `OTEL_EXPORTER_OTLP_HEADERS`. This uses explicit telemetry export; the translated server no longer has the JVM hooks used by Java instrumentation agents.
+
+A dedicated exporter thread batches spans. If the collector is slow or unavailable, request handling does not wait indefinitely for it. A bounded queue eventually drops spans and records the drops. That preserves the service at the cost of incomplete telemetry, which is itself a condition to monitor.
+
+## Track latency without a metric for every URL
+
+The server records request duration, active requests, open connections, database pool counts and task queue depth. Scheduled jobs report duration and outcome. The default metric export interval is one minute, using cumulative temporality.
+
+Route labels use `/orders/{id}`, not `/orders/81379`. Putting each order ID into a metric label would create a new time series for every order. Templates keep the series count bounded by the API's shape.
+
+The application can instrument a method too:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.Counted;
+import com.codename1.backend.annotations.Component;
+import com.codename1.backend.annotations.Timed;
+
+@Component
+public class QuoteService {
+ @Timed
+ @Counted
+ public int quoteCents(int quantity) {
+ if (quantity < 1) {
+ throw new IllegalArgumentException("quantity must be positive");
+ }
+ return quantity * 250;
+ }
+}
+```
+
+This deliberately small example creates a duration histogram and call counters, including a failure counter. The default instrument names derive from the class and method. The build weaves the measurement into the method, so a call through `this` is measured too. For a real quote service, validate upper bounds and apply the application's monetary rules.
+
+`@ManagedResource`, `@ManagedAttribute` and `@ManagedOperation` offer a JMX-inspired model for current values and operator actions. Numeric managed getters become gauges. The management transport is the backend's own HTTP API; this is not a JVM JMX server hidden inside the native executable. Follow the [management configuration](/developer-guide/backend-observability/) before exposing operational actions.
+
+## Let an agent check the running application
+
+MCP, the Model Context Protocol, gives a development tool a structured way to ask the server questions. The backend serves tools for listing routes, inspecting beans, reading recent requests and querying the database. After editing a handler, you can call it and inspect the row it wrote from your development tool.
+
+A practical loop is:
+
+1. Start the backend on its development profile.
+2. Inspect `backend_routes`, `backend_beans` and `backend_schema`.
+3. Make the edit, then stop and restart the server. There is no hot reload.
+4. Exercise the handler with `backend_call`.
+5. Check `backend_requests`, `backend_sql` and `backend_metrics`.
+
+The default SQL tool uses a database-enforced read-only transaction unless its caller explicitly requests write access. An application can publish its own methods with `@McpTool`; the build derives JSON Schema from their supported parameter types and calls them directly.
+
+For a tool of your own, here is a complete bean using the generated dispatch:
+
+```java
+package example;
+
+import com.codename1.backend.annotations.McpParam;
+import com.codename1.backend.annotations.McpTool;
+import com.codename1.backend.annotations.Component;
+
+@Component
+public class QuoteTools {
+ private final QuoteService quotes;
+
+ public QuoteTools(QuoteService quotes) {
+ this.quotes = quotes;
+ }
+
+ @McpTool(description = "Returns a quote in cents for a positive quantity.")
+ public int quote(@McpParam("quantity") int quantity) {
+ return quotes.quoteCents(quantity);
+ }
+}
+```
+
+It reuses `QuoteService` above. The description tells an agent when the tool is relevant, and `@McpParam` supplies a stable argument name independent of compiler parameter metadata. Runtime authentication still has to be configured before serving it outside development.
+
+Development tools are omitted by `backendPackage` / `cn1:backend-package` unless deliberately enabled. Outside development, the MCP endpoint requires a bearer token. A tokenless development server is restricted to loopback. Origin checks also matter when a browser can reach that machine. The [MCP chapter](/developer-guide/backend-mcp/) spells out these boundaries.
+
+## Keep collector credentials off the phone
+
+An app can send its own spans through the backend relay. The relay validates the OTLP/JSON payload, applies size and span-count limits, then queues it for export using credentials held by the server.
+
+```properties
+cn1.otel.relay=true
+cn1.otel.relay.token=${RELAY_TOKEN}
+cn1.otel.relay.corsOrigin=https://app.example.com
+```
+
+The CORS setting is for a web app on another origin. An app-carried relay token is not an unextractable secret; the collector's ingest credentials should remain on the backend. A full queue returns 503 so the client can back off.
+
+Start with one real app action that crosses the native backend and an existing enterprise service. Verify that its spans share a trace ID in your collector, then check consent, sampling, queue drops and access to the relay before expanding collection. The goal is to make the app and its native server observable parts of the system your operations team already runs.
+
+---
+
+## Discussion
+
+_Which part of your application is hardest to connect to an end-to-end trace?_
+
+{{< giscus >}}
diff --git a/docs/website/content/blog/parparvm-four-byte-header.md b/docs/website/content/blog/parparvm-four-byte-header.md
new file mode 100644
index 00000000000..6d942389d97
--- /dev/null
+++ b/docs/website/content/blog/parparvm-four-byte-header.md
@@ -0,0 +1,164 @@
+---
+title: "Honey, I Shrunk Java"
+slug: parparvm-four-byte-header
+url: /blog/parparvm-four-byte-header/
+date: '2026-10-03'
+author: Shai Almog
+description: "ParparVM translates its compiler with 37.5% less time and 45.8% less peak memory in the Linux ARM64 baseline. See the object, compiler and GC changes behind it."
+feed_html: '
ParparVM translates its compiler with 37.5% less time and 45.8% less peak memory in the Linux ARM64 baseline. See the object, compiler and GC changes behind it.'
+series: ["release-2026-10-02"]
+---
+
+
+
+The current Linux ARM64 performance baseline has ParparVM translating its own compiler in **37.5% less elapsed time and 45.8% less peak memory than JDK 25**. On the Linux x64 `Xeon Platinum 8370C` baseline, the same workload takes **56.6% less time and 49.1% less memory**. Your Java source does not need to change to benefit from a smaller runtime and a compiler that removes more work.
+
+[](/blog/runtime-diagrams/translation-baselines.png)
+
+These are the repository's [checked-in performance baselines](https://github.com/codenameone/CodenameOne/blob/60c4f310bddcfc51e5acc75c63a57c43c73430d3/vm/selfhost/perf-baseline.json), read on October 1. They are recorded reference results used to detect regressions, not new measurements made for this article. Each comparison runs the same translator classes on the two runtimes and verifies the generated files byte for byte.
+
+| Self-translation baseline | Elapsed time, ParparVM / JDK 25 | Peak memory, ParparVM / JDK 25 | Recorded calibration runs |
+| --- | ---: | ---: | ---: |
+| Linux ARM64, Neoverse N2 | 0.625 | 0.542 | 7 |
+| Linux x64, EPYC 7763 | 0.484 | 0.519 | 3 |
+| Linux x64, Xeon Platinum 8370C | 0.434 | 0.509 | 3 |
+
+*Lower is better in both columns. JDK 25 is 1.0. Each baseline is the median of the recorded runs' median ratios, with each platform using its available CPUs and runtime defaults. Translation time includes the whole process; Linux memory is peak RSS. They are separate machines, not a core-count scaling test.*
+
+A couple of weeks ago I wrote about [making ParparVM compile itself](/blog/parparvm-compiles-itself/). HotSpot beat us on elapsed time. That was disappointing, though hardly surprising. Since then we have worked on object layout, collections, generated C and garbage collection. The results above are a much better place to be.
+
+The smaller objects matter beyond the compiler benchmark. In [Friday's server comparison](/blog/java-server-work-before-startup/), CN1's native backend peaks at **`57.8 MiB` RSS**, against **`117.0 MiB`** for Spring/GraalVM, and rests at **`29.8 MiB`** after load against **`79.6 MiB`**. That compares complete HTTP stacks. Here we will look at the runtime changes that help make a smaller Java process possible.
+
+## What gets faster, and what still needs work?
+
+Self-translation is a substantial Java workload: allocating objects, walking collections, resolving methods and writing generated C. It is also our own compiler, so we should check other workloads before treating it as a verdict on Java performance.
+
+The complete Linux ARM64 baseline contains 13 workloads. ParparVM uses less peak memory in all 13 and less elapsed time in eight. Sequential array access takes 0.362 times the JDK's measured time; hash-map churn uses 0.121 times its peak process memory. Allocation remains an important weakness: that workload takes 3.043 times the JDK's time, even while using 0.239 times its peak memory.
+
+[](/blog/runtime-diagrams/arm64-baselines.png)
+
+*Each row combines seven calibration runs; each run compares the two runtimes in alternating order. Translation rows measure the complete process. The smaller workloads time repetitions inside the process after their own warmup, so JVM startup does not count against HotSpot. Memory is whole-process peak RSS in every row, not live heap.*
+
+The [performance harness](https://github.com/codenameone/CodenameOne/blob/master/vm/selfhost/perf-gate.py) checks workload results as well as time and memory. The current baseline is a different comparison from the earlier experiment using a warmed JDK 25 AOT cache. In that experiment, self-translation used 0.74, 0.76 and 0.84 times HotSpot's elapsed time at one, two and four logical cores. That cache is part of HotSpot's startup work, not a GraalVM native executable.
+
+Elapsed time and CPU time also answer different questions. Parallel JIT compilation and collection can reduce the wait while consuming more CPU across threads. That distinction helped guide the investigation, but it does not establish a battery saving: energy depends on the machine's power use over time. The current baseline records elapsed time and peak memory, so those are the claims we can make from it.
+
+## Why a tiny Java object needs a header
+
+An object header is runtime metadata stored alongside your fields. It lets the runtime identify the object's class and track information needed for collection and other operations. On a typical 64-bit HotSpot configuration, the header occupies 12 bytes; without compressed class pointers it can occupy 16. JDK 25's optional compact object headers reduce that to 8 bytes. [Oracle's JDK 25 GC guide](https://docs.oracle.com/en/java/javase/25/gctuning/other-considerations.html) documents the sizes and the `-XX:+UseCompactObjectHeaders` switch.
+
+This is the work associated with **Project Lilliput**. **Project Leyden** addresses startup, warmup and footprint through ahead-of-time work, including the AOT cache used in the earlier comparison. The names are easy to mix up, but shrinking each object's header and caching class-loading work solve different problems. See the [Leyden project](https://openjdk.org/projects/leyden/) for that distinction.
+
+| Runtime layout | Object header metadata | What the number excludes |
+| --- | ---: | --- |
+| HotSpot, compressed class pointers | 12 bytes | Fields, alignment and backing storage |
+| HotSpot, JDK 25 compact headers enabled | 8 bytes | Fields, alignment and backing storage |
+| ParparVM release layout | 4 bytes | Fields, alignment, side tables and backing storage |
+
+These are layout sizes, not a prediction of process memory. A small HTTP server can spend more of its resident memory on stacks, code, allocator pages and library state than on live Java object headers. The [server comparison](/blog/java-server-work-before-startup/) measures the whole process separately.
+
+The release object header carries a 16-bit class index, an 8-bit collection epoch and an 8-bit heap state. The class index addresses a closed-world class table instead of storing a pointer in every object. Objects requiring a legacy heap index use a side table keyed by address.
+
+[](/blog/runtime-diagrams/object-header.svg)
+
+The [runtime header](https://github.com/codenameone/CodenameOne/blob/master/vm/ByteCodeTranslator/src/cn1_globals.h) is explicit about the distinction between metadata and allocation. The C header struct remains eight-byte aligned. Small objects live in allocator size classes, and fields need alignment too. A four-byte header does not make an empty object a four-byte allocation.
+
+The translator packs eligible fields into the gap after the metadata. It stores fields at their real widths and orders them to reduce padding. A subclass must preserve its superclass layout as a prefix, so it cannot arbitrarily reach back and fill a hole belonging to an ancestor. That restriction sharply reduced the savings predicted by an early census.
+
+| Object in the experiment | Before | After four-byte header and root-field packing |
+| --- | ---: | ---: |
+| `VarOp` | 32 bytes | 24 bytes |
+| `ArrayList` | 32 bytes | 24 bytes |
+| `ByteCodeMethodArg` | 32 bytes | 24 bytes |
+| `BasicInstruction` | 40 bytes | 32 bytes |
+
+*Object sizes from the layout experiment. Backing storage is additional.*
+
+In the same five-run comparison, this layout change moved one-core container RSS from 618 MB to 605 MB. That is useful, but much smaller than “we halved the header” might suggest. The page allocator and native collection buffers still occupy memory.
+
+There was a second trap. A static class table that named every class also kept those classes reachable to the native linker. The current implementation registers most entries as classes are used. Shrinking object metadata should not accidentally force otherwise unused classes into the executable.
+
+## Get less overhead from the same Java loop
+
+ParparVM translates bytecode to C. “Lowering” is the step that turns a higher-level operation into a representation the native compiler can optimize directly. We do not get that benefit merely by giving Clang a large pile of C functions.
+
+Consider a collection traversal. The ordinary implementation has an iterator object and virtual calls for `hasNext()` and `next()`. When the translator proves the exact collection layout, it can emit a native cursor loop. When it cannot prove the receiver, it can check the exact class once and retain the ordinary iterator as a fallback.
+
+{{< mermaid >}}
+flowchart TD
+ Loop[Collection traversal] --> Proof{Exact supported layout?}
+ Proof -->|Proved locally| Cursor[Native cursor loop]
+ Proof -->|Unknown receiver| Guard[Check exact class once]
+ Guard -->|Matches| Cursor
+ Guard -->|Other class| Iterator[Ordinary iterator]
+ Cursor --> Rules[Keep owner alive and preserve modification checks]
+{{< /mermaid >}}
+
+The owner must remain a GC root until the final native-buffer access. A raw pointer into a `malloc` block does not keep the Java owner alive. The emitted lifetime fence is therefore part of correctness, not optional bookkeeping to strip from a fast loop.
+
+Several related changes attack allocation and dispatch:
+
+- **Collection storage:** hash tables combine key, value and metadata slices into one native allocation. Reference slices still need tracing and write barriers. Moving them outside the managed heap does not make their Java references invisible to the collector.
+- **Strings and builders:** `StringBuilder` keeps Latin-1 bytes until it needs UTF-16. Proven temporary builders can use native storage while preserving ownership across helper calls and exceptions. `StringBuffer` retains its synchronization.
+- **Short string equality:** bounded loads compare short strings without an ordinary Java method call. Longer ranges still use `memcmp`; mixed encodings preserve their own comparison rules. The implementation must not read past the logical range just because a wide load would be convenient.
+- **Immediate array streams:** supported `Stream.of(array)` pipelines with known lambda callbacks can become one C loop. Escaping streams, unknown callbacks, `sorted`, `distinct` and unsupported terminals keep the lazy implementation.
+
+For example, this shape is eligible for the stream work when the surrounding method satisfies the proof:
+
+```java
+long count = java.util.stream.Stream.of(names)
+ .filter(name -> name.length() > 3)
+ .count();
+```
+
+Here `names` is a `String[]`. Eligibility is narrower than “streams allocate nothing.” Nor does seeing a loop in emitted C prove that the linked binary vectorizes it. The lowering audit checks generated code and linked instructions separately from elapsed-time measurements.
+
+## Keep your program correct when removing work
+
+A declared `List` type does not prove an `ArrayList` layout. `LocalReceiverTypes` tracks allocation provenance, and unknown parameters or factory results retain guards. Analysis is restricted to methods that need it, and the compiler drops the temporary frame information after capturing the proof. Optimizing the translated program should not require keeping an unnecessary analysis graph alive throughout translation.
+
+Direct calls also gain small C intrinsics for operations such as list access, string length, hashing and builder appends. They apply to calls whose target is resolved statically, with the ordinary implementation available off the fast path. Together with traversal lowering, this lets the C compiler see useful operations inside a loop instead of opaque calls at every step.
+
+Another pass removes instance fields the closed program never reads. It checks native-source references and conservatively keeps runtime fields and unresolved cases. Removing a dead reference field can save both its storage and the object it would otherwise retain. This pass is disabled for JavaScript output and on-device debugging.
+
+There is a semantic edge worth stating: the current [dead-field pass](https://github.com/codenameone/CodenameOne/blob/master/vm/ByteCodeTranslator/src/com/codename1/tools/translator/DeadFieldElimination.java) documents that assigning to a removed field on a null receiver no longer produces the JVM's `NullPointerException`. Its treatment of an unused store is therefore not a claim of identical behavior for every Java program. An application depending on that exception needs to account for this difference.
+
+## Fit the collector to the cores you have
+
+The small-object allocator groups objects into pages by size, often called BiBOP, short for “big bag of pages.” A nonmoving collector cannot return a page while one live object still occupies it. Free slots inside a partial page can be reusable capacity without being releasable memory.
+
+The experiments found 50 to 60 MB of free slots inside partial pages around one peak. Those slots were reused before new pages were allocated. Calling all of that a leak would send the investigation in the wrong direction.
+
+On one core, the generational collector can stop application work and collect young objects. With spare cores, the concurrent collector overlaps tracing with the application. The concurrent path needs grace for allocations that appear after a snapshot. That can retain dead objects longer, and shortening that lifetime requires preserving everything the snapshot could not yet see.
+
+We tried reclaiming dead large objects every single-core cycle. The first attempts were unsound. A growing output buffer could be allocated after the extent snapshot and remain live only in a thread's local state. If the collector could not resolve that pointer, it could free a live buffer.
+
+The fix registers those large objects from allocation and rebuilds the relevant snapshot at each thread's pause in that mode. The concurrent collector keeps its different grace rules. Applying one mode's shortcut to the other added locking to a hot path without providing a benefit.
+
+| One-core translation, five interleaved rounds | Minimum elapsed | Maximum RSS |
+| --- | ---: | ---: |
+| JDK 25 | 13.74 s | 557 MB |
+| Four-byte header before reclamation change | 10.29 s | 608 MB |
+| With large-object reclamation change | 9.84 s | 503 MB |
+
+*Linux container experiment isolating the reclamation change: minimum elapsed and maximum RSS from five interleaved runs. Lower is better. These historical results explain the change; the opening charts show the current baseline.*
+
+We then reduced work in minor collections: skip an already-old page object before expensive conservative resolution, and consult the monitor table only for pages that have had monitors. The experiment record includes the unsuccessful alternatives too. Fewer object bytes help memory use. Avoiding thousands of unnecessary collector operations helps execution time too.
+
+## What changes for your app?
+
+If your application creates large graphs of small objects, the smaller headers and field packing can reduce their cost without a source rewrite. Proven collection traversals and stream pipelines can avoid temporary objects and dispatch. These are compiler and runtime changes, so you get them by rebuilding with a release that includes this work.
+
+The benefit depends on what your app spends time and memory doing. A form with a large model, an importer that walks collections, and a service that allocates objects continuously stress different parts of the runtime. The allocation result above is a reason to check a busy handler before assuming it will behave like the compiler benchmark.
+
+For an existing Codename One app, rebuild and compare a real interaction on your target device: startup, a large list or model load, and a sustained operation that creates objects. For a backend, compare resident memory at rest and under representative traffic, plus throughput and latency. Keep the input and build settings the same between releases. The [backend guide](/developer-guide/backend/) covers packaging a small service you can test this way.
+
+There is more room to improve. Our measurements point toward shorter-lived garbage in the concurrent collector and less overhead in small native collection buffers. A stop-the-world strategy saves memory on one core, but forcing it everywhere can lose too much execution time. The next step is to reduce that retention while preserving useful concurrency. That is an optimization direction, not a promise that one collector will win on every application.
+
+---
+
+## Discussion
+
+_When you compare runtimes, do you record CPU time as well as the time you waited?_
+
+{{< giscus >}}
diff --git a/docs/website/static/blog/browser-desktop-theme.jpg b/docs/website/static/blog/browser-desktop-theme.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..eafe827bf2adc5226b75b4d2bbf7b02fc7d027eb
GIT binary patch
literal 65333
zcmeEv2UJwcmUgR%AUR8x3?j5-2@O|r5RjlKQ8G=GoZ+hEoSTf~93)Frat=+-l2enR
z$?!LD-_v*Byje4AX5O2BjfVwYoUp5E*RFl4zWQqS<>=*i0JgNalsMqlEdbya;s