eclipse-zenoh · milyin · Apr 19, 2026 · Apr 18, 2026 · Apr 19, 2026 · Apr 19, 2026
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -9,9 +9,6 @@ on:
     - cron: "0 6 * * 1-5"
   workflow_dispatch:
 
-env:
-  CARGO_TERM_COLOR: always
-
 jobs:
   build:
     name: Build on ${{ matrix.os }}
@@ -23,43 +20,21 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
 
       - uses: actions/setup-java@v4
         with:
           distribution: temurin
           java-version: 11
 
-      - name: Install Rust toolchain
-        run: |
-          rustup show
-          rustup component add rustfmt clippy
-
-      - name: Cargo Format
-        working-directory: zenoh-jni
-        run: cargo fmt --all --check
-
-      - name: Clippy Check without Cargo.lock
-        working-directory: zenoh-jni
-        run: |
-          rm Cargo.lock
-          cargo clippy --all-targets --all-features -- -D warnings
-          git restore Cargo.lock
-
-      - name: Check for feature leaks
-        working-directory: zenoh-jni
-        run: cargo test --no-default-features
-
-      - name: Build Zenoh-JNI
-        working-directory: zenoh-jni
-        run: cargo build
-
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
         with:
           gradle-version: 8.12.1
 
       - name: Gradle Test
-        run: gradle jvmTest --info
+        run: gradle jvmTest --info -Pzenoh.useLocalJniRuntime=true
 
   markdown_lint:
     runs-on: ubuntu-latest

diff --git a/.github/workflows/publish-android.yml b/.github/workflows/publish-android.yml
@@ -17,9 +17,6 @@ on:
         required: false
         default: true
 
-env:
-  CARGO_TERM_COLOR: always
-
 jobs:
   publish_android_package:
     name: Publish Android package
@@ -37,25 +34,6 @@ jobs:
           distribution: temurin
           java-version: 11
 
-      - uses: nttld/setup-ndk@v1
-        id: setup-ndk
-        with:
-          ndk-version: r26
-          add-to-path: false
-          link-to-sdk: true
-
-      - name: Install Rust toolchain
-        run: |
-          rustup show
-          rustup component add rustfmt clippy
-
-      - name: Setup Rust toolchains
-        run: |
-          rustup target add armv7-linux-androideabi
-          rustup target add i686-linux-android
-          rustup target add aarch64-linux-android
-          rustup target add x86_64-linux-android
-
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
         with:

diff --git a/.github/workflows/publish-jvm.yml b/.github/workflows/publish-jvm.yml
@@ -17,127 +17,9 @@ on:
         required: false
         default: true
 
-env:
-  CARGO_TERM_COLOR: always
-  JNI_LIB_PATHS: jni-libs # Edit on the inner build.gradle.kts file as well.
-
 jobs:
-  builds:
-    name: Build for ${{ matrix.job.target }} on ${{ matrix.job.os }}
-    if: ${{ !(github.event.inputs.build == 'false') }}
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        job:
-          # In order to load any added target at runtime, editing the Zenoh class under jvmMain is required.
-          - {
-              target: x86_64-unknown-linux-gnu,
-              arch: amd64,
-              os: ubuntu-latest,
-              build-cmd: "cargo",
-            }
-          - {
-              target: aarch64-unknown-linux-gnu,
-              arch: arm64,
-              os: ubuntu-latest,
-              build-cmd: "cross",
-            }
-          - {
-              target: x86_64-apple-darwin,
-              arch: darwin,
-              os: macos-latest,
-              build-cmd: "cargo",
-            }
-          - {
-              target: aarch64-apple-darwin,
-              arch: darwin,
-              os: macos-latest,
-              build-cmd: "cargo",
-            }
-          - {
-              target: x86_64-pc-windows-msvc,
-              arch: win64,
-              os: windows-latest,
-              build-cmd: "cargo",
-            }
-          - {
-            target: aarch64-pc-windows-msvc,
-            arch: arm64,
-            os: windows-latest,
-            build-cmd: "cargo",
-          }
-    steps:
-      - name: Checkout source code
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.branch }}
-
-      - name: Install prerequisites
-        shell: bash
-        run: |
-          case ${{ matrix.job.target }} in
-            *-linux-gnu*) cargo +stable install cargo-deb --locked ;;
-          esac
-
-          case ${{ matrix.job.target }} in
-            aarch64-unknown-linux-gnu)
-              sudo apt-get -y update
-              sudo apt-get -y install gcc-aarch64-linux-gnu
-              ;;
-          esac
-
-          cargo +stable install cross --locked
-
-      - name: Install Rust toolchain
-        run: |
-          rustup show
-          rustup target add ${{ matrix.job.target }}
-
-      - name: Build
-        run: ${{ matrix.job.build-cmd }} build --release --bins --lib --features=${{ github.event.inputs.features}} --target=${{ matrix.job.target }} --manifest-path zenoh-jni/Cargo.toml
-
-      - name: Packaging
-        id: package
-        shell: bash
-        run: |
-          TARGET=${{ matrix.job.target }}
-          MAIN_PKG_NAME="${GITHUB_WORKSPACE}/${TARGET}.zip"
-
-          case ${TARGET} in
-            *linux*)
-              cd "zenoh-jni/target/${TARGET}/release/"
-              echo "Packaging ${MAIN_PKG_NAME}:"
-              zip ${MAIN_PKG_NAME} libzenoh_jni.so
-              cd -
-              echo "MAIN_PKG_NAME=${MAIN_PKG_NAME}" >> $GITHUB_OUTPUT
-              ;;
-            *apple*)
-              cd "zenoh-jni/target/${TARGET}/release/"
-              echo "Packaging ${MAIN_PKG_NAME}:"
-              zip ${MAIN_PKG_NAME} libzenoh_jni.dylib
-              cd -
-              echo "MAIN_PKG_NAME=${MAIN_PKG_NAME}" >> $GITHUB_OUTPUT
-              ;;
-            *windows*)
-              cd "zenoh-jni/target/${TARGET}/release/"
-              echo "Packaging ${MAIN_PKG_NAME}:"
-              7z -y a "${MAIN_PKG_NAME}" zenoh_jni.dll
-              cd -
-              echo "MAIN_PKG_NAME=${MAIN_PKG_NAME}" >> $GITHUB_OUTPUT
-              ;;
-          esac
-
-      - name: "Upload packages"
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.job.target }}
-          path: |
-            ${{ steps.package.outputs.MAIN_PKG_NAME }}
-
   publish_jvm_package:
     name: Publish JVM package
-    needs: builds
     permissions:
       contents: read
       packages: write
@@ -148,14 +30,6 @@ jobs:
         with:
           ref: ${{ inputs.branch }}
 
-      - name: Create resources destination
-        run: mkdir ${{env.JNI_LIB_PATHS}}
-
-      - name: Download result of previous builds
-        uses: actions/download-artifact@v4
-        with:
-          path: ${{env.JNI_LIB_PATHS}}
-
       - uses: actions/setup-java@v4
         with:
           distribution: temurin

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -106,15 +106,3 @@ jobs:
     with:
       live-run: ${{ inputs.live-run || false }}
       branch: ${{ needs.tag.outputs.branch }}
-
-  publish-github:
-    needs: [tag, publish-android, publish-jvm]
-    runs-on: macos-latest
-    steps:
-      - uses: eclipse-zenoh/ci/publish-crates-github@main
-        with:
-          repo: ${{ github.repository }}
-          live-run: ${{ inputs.live-run || false }}
-          version: ${{ needs.tag.outputs.version }}
-          branch: ${{ needs.tag.outputs.branch }}
-          github-token: ${{ secrets.BOT_TOKEN_WORKFLOW }}
diff --git a/.gitmodules b/.gitmodules
@@ -0,0 +1,4 @@
+[submodule "zenoh-java"]
+	path = zenoh-java
+	url = https://github.com/eclipse-zenoh/zenoh-java.git
+	branch = common-jni
diff --git a/README.md b/README.md
@@ -118,14 +118,15 @@ For the moment, the library targets the following platforms:
 
 Basically:
 
-- Rust ([Installation guide](https://doc.rust-lang.org/cargo/getting-started/installation.html))
 - Kotlin ([Installation guide](https://kotlinlang.org/docs/getting-started.html#backend))
 - Gradle ([Installation guide](https://gradle.org/install/))
 
 and in case of targetting Android you'll also need:
 
 - Android SDK ([Installation guide](https://developer.android.com/about/versions/11/setup-sdk))
 
+> **Note:** zenoh-kotlin no longer builds its own native JNI library. The native runtime is provided by [zenoh-jni-runtime](https://github.com/eclipse-zenoh/zenoh-java), which is a published Maven artifact that zenoh-kotlin depends on automatically. No Rust toolchain is required to build or publish zenoh-kotlin using the default (Maven) path. A Rust toolchain is only needed when using the [local submodule path](#running-the-tests) with `-Pzenoh.useLocalJniRuntime=true`.
+
 ## <img src="jvm.png" alt="JVM" height="50"> JVM
 
 To publish a library for a JVM project into Maven local, run
@@ -134,11 +135,7 @@ To publish a library for a JVM project into Maven local, run
 gradle publishJvmPublicationToMavenLocal
 ```
 
-This will first, trigger the compilation of Zenoh-JNI, and second publish the library into maven local, containing the native library
-as a resource that will be loaded during runtime.
-
-:warning: The native library will be compiled against the default rustup target on your machine, so although it may work fine
-for you on your desktop, the generated publication may not be working on another computer with a different operating system and/or a different cpu architecture.
+This publishes the zenoh-kotlin library to Maven local. The published artifact declares a dependency on `zenoh-jni-runtime`, which provides the native JNI binaries and is published separately by the [zenoh-java](https://github.com/eclipse-zenoh/zenoh-java) project.
 
 Once we have published the package, we should be able to find it under `~/.m2/repository/org/eclipse/zenoh/zenoh-kotlin-jvm/1.1.1`.
 
@@ -157,40 +154,13 @@ dependencies {
 
 ## <img src="android-robot.png" alt="Android" height="50"> Android
 
-In order to use these bindings in a native Android project, what we will do is to build them as an Android NDK Library,
-publishing it into Maven local for us to be able to easily import it in our project.
-
-It is required to have the [NDK (native development kit)](https://developer.android.com/ndk) installed, since we are going to compile Zenoh JNI for multiple
-android native targets. The currently used NDK version is **26.0.10792818**.
-It can be set up by using Android Studio (go to `Preferences > Languages & Frameworks > Android SDK > SDK Tools`, tick `Show Package Details` and pick the right NDK version),
-or alternatively it can be found [here](https://developer.android.com/ndk/downloads).
-
-The native platforms we are going to target are the following ones:
-
-- x86
-- x86_64
-- arm
-- arm64
-
-Therefore, if they are not yet already added to the Rust toolchain, run:
-
-```bash
-rustup target add armv7-linux-androideabi; \
-rustup target add i686-linux-android; \
-rustup target add aarch64-linux-android; \
-rustup target add x86_64-linux-android
-```
-
-to install them.
-
-So, in order to publish the library onto Maven Local, run:
+In order to use these bindings in a native Android project, publish them into Maven local:
 
 ```bash
 gradle -Pandroid=true publishAndroidReleasePublicationToMavenLocal
 ```
 
-This will first trigger the compilation of the Zenoh-JNI for the previously mentioned targets, and secondly will
-publish the library, containing the native binaries.
+This publishes the zenoh-kotlin-android artifact to Maven local. The published artifact declares a dependency on `zenoh-jni-runtime`, which provides the prebuilt native JNI binaries for Android ABIs (x86, x86_64, arm, arm64). The native binaries are published separately by the [zenoh-java](https://github.com/eclipse-zenoh/zenoh-java) project — no Rust toolchain or NDK cross-compilation is required.
 
 You should now be able to see the package under `~/.m2/repository/org/eclipse/zenoh/zenoh-kotlin-android/1.1.1`.
 
@@ -226,13 +196,25 @@ gradle dokkaGenerate
 
 ## Running the tests
 
-To run the tests, run:
+zenoh-kotlin supports two modes for providing the native JNI runtime during tests:
+
+### Default mode (published Maven artifact)
+
+By default, tests resolve `zenoh-jni-runtime` from Maven Central. No local submodule or Rust toolchain is needed:
 
 ```bash
 gradle jvmTest
 ```
 
-This will compile the native library on debug mode (if not already available) and run the tests afterward against the JVM target.
+### Local submodule mode (opt-in)
+
+For local integration testing against the `zenoh-java` submodule (included under `zenoh-java/`), pass the `zenoh.useLocalJniRuntime` property. This substitutes the Maven dependency with a local composite build of the submodule:
+
+```bash
+gradle jvmTest -Pzenoh.useLocalJniRuntime=true
+```
+
+> **Note:** The local submodule path builds `zenoh-jni-runtime` from source and requires a Rust toolchain (see [rustup.rs](https://rustup.rs)) as well as the Cargo toolchain configured for the target platform. The submodule's Gradle build handles the Rust compilation step automatically once the toolchain is installed.
 
 ## Logging
 

diff --git a/build.gradle.kts b/build.gradle.kts
@@ -18,8 +18,7 @@ buildscript {
     }
     dependencies {
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0")
-        classpath("org.mozilla.rust-android-gradle:plugin:0.9.6")
-        classpath("com.android.tools.build:gradle:7.4.2")
+classpath("com.android.tools.build:gradle:7.4.2")
         classpath("com.gradleup.shadow:shadow-gradle-plugin:9.0.0-beta6")
     }
 }
@@ -28,8 +27,7 @@ plugins {
     id("com.android.library") version "7.4.2" apply false
     id("org.jetbrains.kotlin.android") version "1.9.10" apply false
     id("org.jetbrains.kotlin.multiplatform") version "1.9.0" apply false
-    id("org.mozilla.rust-android-gradle.rust-android") version "0.9.6" apply false
-    id("org.jetbrains.dokka") version "2.0.0" apply false
+id("org.jetbrains.dokka") version "2.0.0" apply false
     id("com.adarshr.test-logger") version "3.2.0" apply false
     kotlin("plugin.serialization") version "1.9.0" apply false
     id("io.github.gradle-nexus.publish-plugin") version "2.0.0"