Android toolchain

Elide builds, runs, tests and ships Android applications and libraries from elide.pkl, with no Gradle and no Android Gradle Plugin. The Android SDK’s own tools (aapt2, d8, R8, zipalign, apksigner, bundletool) run as build tasks, so elide build --inspect lists every step and a second build runs only what changed.

Create and run an app

mkdir hello-android
cd hello-android
elide init --template android --plain --skip-defaults -- package=com.example.hello
elide run

On a machine with nothing but Elide installed, elide run:

1. Looks for an Android SDK in ANDROID_HOME, ANDROID_SDK_ROOT and the location Android Studio installs it in, and uses Elide’s managed SDK under ~/.elide/toolchains/android when none is found (Android SDK).
2. Asks once to accept the Android SDK licenses, then installs the platform, build-tools, platform-tools, emulator and system image the project needs.
3. Builds the app APK and signs it with the Android debug keystore, ~/.android/debug.keystore, created on first use.
4. Installs it on the one attached device, or creates and boots the project’s emulator when none is attached.
5. Launches the app and prints its log until you press Ctrl+C or the app exits.

The license question is asked only on a terminal. In CI, accept the licenses explicitly and install first:

elide install --accept-android-licenses
elide build

The emulator needs hardware acceleration. On Linux that is /dev/kvm and membership of the kvm group; without it the emulator fails before booting and says so (Headless hosts, CI and WSL).

The template

elide.pkl
src/main/kotlin/com/example/hello/MainActivity.kt
src/androidTest/kotlin/com/example/hello/MainActivityTest.kt

amends "elide:project.pkl"

import "elide:Android.pkl" as Android

name = "android-app"
version = "1.0.0"

android {
  namespace = "com.example.hello"
  compileSdk = 36
  minSdk = 30

  // Generates `AndroidManifest.xml`; a `src/main/AndroidManifest.xml`, if added, is merged over it.
  application {
    label = "@string/app_name"
    theme = "@android:style/Theme.Material.Light.NoActionBar"
    allowBackup = false
    activities { ["MainActivity"] { launcher = true } }
  }
  resources {
    strings {
      ["app_name"] = "Elide Android App"
      ["greeting"] = "Hello Elide!"
    }
  }
}

kotlin {
  features {
    compose = true
  }
}

dependencies {
  android {
    androidx { ["activity-compose"] = "1.9.3" }
    compose { version = "1.7.8"; modules { "foundation"; "ui-tooling" } }
    test { runner = "1.6.2"; modules { "ext-junit" } }
  }
}

artifacts {
  ["app"] = new Android.AndroidApk {}
}

• android declares the namespace (the package R lives in, and the application id), the API levels, the application’s manifest entries and its strings. No AndroidManifest.xml or strings.xml is needed (Manifest and resources).
• kotlin.features.compose turns on the Compose compiler, and dependencies.android declares the Compose, AndroidX and AndroidX Test libraries by family (Android dependencies).
• app leaves release unset, so it is a debuggable build signed with the debug keystore; elide build --release builds it as a release instead (Signing and release).
• src/androidTest holds an instrumented test, which elide test --device runs on a device (Android tests).

elide init --template android --parameters lists the template’s parameters (project_name, app_name, package, greeting).

Commands

Android projects use the commands every project has. Device behaviour is behind flags, and each command runs a build target that elide build can also run by name (Android build targets).

Artifacts

An application consumes the libraries of its own workspace and published AARs alike: classes, resources, manifests, assets and native libraries merge in one pass (Manifest and resources).

Limits

• Android support ships with every standard Elide distribution. A custom build made without it (--no-android) refuses to build, run or test an Android project, and says so.

• There are no build types or product flavors. Declare one artifact per variant, with its own applicationId, release and resource directories.

• No BuildConfig class is generated, and Android Lint does not run.

• Host tests run against one artifact of a project, chosen by android.hostTests.

• src/androidTest instruments one application: the first APK that is neither a test APK nor minified.

• A bundle with dynamic feature modules cannot be minified.

• A Java resource that several jars carry ships from the first; only META-INF/services files are merged.

• elide lsp serves Java sources only; Kotlin sources get no language server from it.