runanywhere-sdk AAR                  runanywhere-llamacpp AAR             runanywhere-onnx AAR
  jni/{abi}/                           jni/{abi}/                           jni/{abi}/
    libc++_shared.so                     libc++_shared.so                      libc++_shared.so
    libomp.so                            librac_backend_llamacpp.so            libonnxruntime.so
    librac_backend_cloud.so              librac_backend_llamacpp_jni.so        librac_backend_onnx.so
    librac_commons.so                    librunanywhere_llamacpp.so            librac_backend_onnx_jni.so
    librunanywhere_jni.so                                                     librac_backend_sherpa.so
                                                                              librunanywhere_onnx.so
                                                                              librunanywhere_sherpa.so
                                                                              libsherpa-onnx-c-api.so
                                                                              libsherpa-onnx-jni.so

Upload (Gradle) --> Transfer to Portal --> Validate + publish to Maven Central

# Android SDK
export ANDROID_HOME="$HOME/Library/Android/sdk"

# GPG key (import if not already done)
echo "<GPG_SIGNING_KEY_BASE64>" | base64 -d | gpg --batch --import
gpg --list-secret-keys --keyid-format LONG

# Maven Central (Sonatype Central Portal)
mavenCentral.username=YOUR_SONATYPE_USERNAME
mavenCentral.password=YOUR_SONATYPE_PASSWORD

# GPG Signing
signing.gnupg.executable=gpg
signing.gnupg.useLegacyGpg=false
signing.gnupg.keyName=YOUR_GPG_KEY_ID
signing.gnupg.passphrase=YOUR_GPG_PASSPHRASE

# Run from the repository root.
REPO_ROOT="$(git rev-parse --show-toplevel)"
cd "$REPO_ROOT"

export SDK_VERSION=0.20.11
export NATIVE_VERSION=0.20.11
export ANDROID_HOME="$HOME/Library/Android/sdk"
export MAVEN_CENTRAL_USERNAME="<USERNAME>"
export MAVEN_CENTRAL_PASSWORD="<PASSWORD>"
export GPG_KEY_ID="<KEY_ID>"
export GPG_SIGNING_KEY="<BASE64_ARMORED_PRIVATE_KEY>"
export GPG_SIGNING_PASSWORD="<PASSPHRASE>"

NATIVE_ARCHIVES="$(mktemp -d)"
for ABI in arm64-v8a armeabi-v7a x86_64; do
  NAME="RACommons-android-${ABI}-v${NATIVE_VERSION}.zip"
  URL="https://github.com/RunanywhereAI/runanywhere-sdks/releases/download/v${NATIVE_VERSION}"
  curl -fL "$URL/$NAME" -o "$NATIVE_ARCHIVES/$NAME"
  curl -fL "$URL/$NAME.sha256" -o "$NATIVE_ARCHIVES/$NAME.sha256"
  (cd "$NATIVE_ARCHIVES" && shasum -a 256 -c "$NAME.sha256")
done

bash bindings/kotlin/scripts/package-sdk.sh \
  --mode local \
  --natives-from "$NATIVE_ARCHIVES"

cd bindings/kotlin
./gradlew clean \
  :publishReleasePublicationToMavenCentralRepository \
  :modules:runanywhere-core-llamacpp:publishReleasePublicationToMavenCentralRepository \
  :modules:runanywhere-core-onnx:publishReleasePublicationToMavenCentralRepository \
  -Prunanywhere.useLocalNatives=true \
  -x buildLocalJniLibs \
  --no-daemon

# Run from the repository root.
REPO_ROOT="$(git rev-parse --show-toplevel)"
cd "$REPO_ROOT"

export SDK_VERSION=0.20.11
export RAC_RELEASE_VERSION="$SDK_VERSION"
export ANDROID_HOME="$HOME/Library/Android/sdk"
export ANDROID_NDK_HOME="$HOME/Library/Android/sdk/ndk/27.3.13750724"

DIST="$REPO_ROOT/core/dist"
NATIVE_ROOT="$DIST/public-android-natives"
rm -rf "$NATIVE_ROOT"
mkdir -p "$NATIVE_ROOT"

for ABI in arm64-v8a armeabi-v7a x86_64; do
  bash core/scripts/build-android.sh "$ABI"
  ARCHIVE="$DIST/RACommons-android-${ABI}-v${SDK_VERSION}.zip"
  (
    cd "$DIST"
    shasum -a 256 -c "$(basename "$ARCHIVE").sha256"
  )
  unzip -q "$ARCHIVE" -d "$NATIVE_ROOT"
done

# Build and validate the exact public Maven bundle, and stage those validated
# natives into the three Kotlin modules.
bash bindings/kotlin/scripts/package-sdk.sh \
  --mode local \
  --natives-from "$NATIVE_ROOT"

# Publish the same staged inputs.
export MAVEN_CENTRAL_USERNAME="<USERNAME>"
export MAVEN_CENTRAL_PASSWORD="<PASSWORD>"

cd bindings/kotlin
./gradlew clean publishAllPublicationsToMavenCentralRepository \
  -Prunanywhere.useLocalNatives=true \
  -x buildLocalJniLibs \
  --no-daemon

# Run this from the same host/IP that performed the Gradle upload. Sonatype's
# compatibility service groups Maven-like PUT requests by source IP.
CENTRAL_BEARER="$(printf '%s:%s' \
  "$MAVEN_CENTRAL_USERNAME" "$MAVEN_CENTRAL_PASSWORD" |
  base64 | tr -d '\r\n')"

curl --fail --request POST \
  -H "Authorization: Bearer $CENTRAL_BEARER" \
  'https://ossrh-staging-api.central.sonatype.com/manual/upload/defaultRepository/io.github.sanchitmonga22?publishing_type=automatic'

# This flow assumes the compatibility service was clean before the Gradle
# upload. Require exactly one repository for this client IP and namespace so a
# stale or concurrent deployment can never be selected by accident.
REPOSITORIES_JSON="$(curl --fail --silent \
  -H "Authorization: Bearer $CENTRAL_BEARER" \
  'https://ossrh-staging-api.central.sonatype.com/manual/search/repositories?ip=client&profile_id=io.github.sanchitmonga22')"
REPOSITORY_COUNT="$(jq '[.repositories[] | select(.portal_deployment_id != null)] | length' <<<"$REPOSITORIES_JSON")"
[ "$REPOSITORY_COUNT" = 1 ] || {
  echo "Expected exactly one transferred repository; found $REPOSITORY_COUNT" >&2
  exit 1
}
DEPLOYMENT_ID="$(jq -r '.repositories[] | select(.portal_deployment_id != null) | .portal_deployment_id' <<<"$REPOSITORIES_JSON")"
[ -n "$DEPLOYMENT_ID" ] && [ "$DEPLOYMENT_ID" != null ]

# Poll for at most 15 minutes. Automatic deployments normally pass through
# PENDING -> VALIDATING -> PUBLISHING -> PUBLISHED.
DEPLOYMENT_STATE=
for attempt in $(seq 1 90); do
  STATUS_JSON="$(curl --fail --silent --request POST \
    -H "Authorization: Bearer $CENTRAL_BEARER" \
    "https://central.sonatype.com/api/v1/publisher/status?id=$DEPLOYMENT_ID")"
  DEPLOYMENT_STATE="$(jq -r '.deploymentState' <<<"$STATUS_JSON")"
  case "$DEPLOYMENT_STATE" in
    PUBLISHED) break ;;
    FAILED)
      jq '.errors' <<<"$STATUS_JSON" >&2
      exit 1
      ;;
    PENDING|VALIDATING|PUBLISHING) sleep 10 ;;
    VALIDATED)
      echo "Deployment is waiting for manual publication instead of automatic release; publish it in Central Portal or use the Portal publish endpoint, then resume status polling." >&2
      exit 1
      ;;
    *)
      echo "Unexpected Central Portal state: $DEPLOYMENT_STATE" >&2
      exit 1
      ;;
  esac
done
[ "$DEPLOYMENT_STATE" = PUBLISHED ] || {
  echo "Timed out waiting for Central Portal deployment $DEPLOYMENT_ID" >&2
  exit 1
}

for a in runanywhere-sdk runanywhere-llamacpp runanywhere-onnx; do
  echo "$a: $(curl -s -o /dev/null -w '%{http_code}' \
    "https://repo1.maven.org/maven2/io/github/sanchitmonga22/$a/$SDK_VERSION/$a-$SDK_VERSION.pom")"
done

# After staging QHexRT natives via:
#   QHexRT/tools/scripts/stage_prebuilt_for_sdk.sh ...
#   RAC_BUILD_JOBS=2 ./scripts/build/build-core-android.sh arm64-v8a

export SDK_VERSION=0.20.11
export MAVEN_CENTRAL_USERNAME="<USERNAME>"
export MAVEN_CENTRAL_PASSWORD="<PASSWORD>"
export GPG_KEY_ID="<KEY_ID>"
export GPG_SIGNING_KEY="<BASE64_ARMORED_PRIVATE_KEY>"
export GPG_SIGNING_PASSWORD="<PASSPHRASE>"

bash bindings/kotlin/scripts/package-qhexrt.sh --mode local

cd bindings/kotlin
./gradlew :modules:runanywhere-core-qhexrt:publishReleasePublicationToMavenCentralRepository \
  -Prunanywhere.useLocalNatives=true \
  -x buildLocalJniLibs \
  --no-daemon

implementation("io.github.sanchitmonga22:runanywhere-sdk:0.20.11")
implementation("io.github.sanchitmonga22:runanywhere-qhexrt-android:0.20.11")

// settings.gradle.kts
repositories {
    mavenCentral()
}

// build.gradle.kts
dependencies {
    // Required: core SDK
    implementation("io.github.sanchitmonga22:runanywhere-sdk:0.20.11")

    // Optional: LLM + VLM (add only if you need text/vision generation)
    implementation("io.github.sanchitmonga22:runanywhere-llamacpp:0.20.11")

    // Optional: STT/TTS/VAD (add only if you need speech features)
    implementation("io.github.sanchitmonga22:runanywhere-onnx:0.20.11")

    // Optional: Snapdragon Hexagon NPU (arm64-v8a only)
    implementation("io.github.sanchitmonga22:runanywhere-qhexrt-android:0.20.11")
}