Eximia docs

Quickstart

From zero to an installable APK in under 10 minutes. Assumes Linux x86_64 or macOS arm64 + Android SDK + JDK 17.

1 · Install

curl -fsSL https://slmeximia.site/install.sh | sh

The installer:

Detects your OS + arch
Downloads the matching slm-eximia binary from slmeximia.site/downloads/
Verifies the SHA-256 before installing (refuses on mismatch)
Drops it into ~/.local/bin/eximia (override with EXIMIA_INSTALL_DIR)

Add ~/.local/bin to your $PATH if it isn't already, then:

eximia --version
# slm-eximia 0.2.0

2 · Verify the toolchain

eximia doctor

You need:

JDK 17 (any distro). Verify: java -version.
Android SDK 35 with build-tools 35.0.0 + platform-tools. Easiest install: Android Studio → SDK Manager. ANDROID_HOME must be exported.
Gradle 8.x on $PATH. Most distros: sdk install gradle or download from gradle.org.

For iOS you additionally need Xcode 15+ on a macOS arm64 host. Linux can't produce IPAs; pass --remote to ship the build to a mac runner over SSH.

3 · Scaffold a project

eximia init hello --app-id com.example.hello --no-git
cd hello

You get:

hello/
├── eximia.json          # project manifest (platforms, plugins, signing)
└── www/
    └── index.html       # your app's entry point

eximia.json declares the platforms and plugin set. Default ships empty:

{
  "appId": "com.example.hello",
  "appName": "hello",
  "version": "1.0.0",
  "platforms": ["android"],
  "plugins": []
}

4 · Add the device-info plugin (the public example)

Edit eximia.json and reference the bundled plugin by name:

{
  "appId": "com.example.hello",
  "appName": "hello",
  "version": "1.0.0",
  "platforms": ["android"],
  "plugins": ["device-info"]
}

No eximia plugin add step needed — bundled plugins resolve directly from the binary's embedded cache. eximia plugins list shows the full set.

5 · Call it from JavaScript

Replace www/index.html:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <title>hello</title>
  <script src="eximia.umd.js"></script>
</head>
<body>
  <h1>Device</h1>
  <pre id="out">loading…</pre>
  <script>
    SLMEximia.exec("SLMDeviceInfo", "getInfo", {})
      .then(info => {
        document.getElementById("out").textContent =
          JSON.stringify(info, null, 2);
      })
      .catch(err => {
        document.getElementById("out").textContent =
          "error: " + err.message;
      });
  </script>
</body>
</html>

The runtime injects SLMEximia as a global; eximia.umd.js is pre-loaded by the WebView at boot, no <script> tag for it is strictly required (the example above includes it for clarity).

6 · Build the APK

eximia build android

You'll see Gradle output:

✓ android build skeleton staged in build/android (release=false, plugins=1)
→ running `gradle :app:assembleDebug`
…
BUILD SUCCESSFUL in 11s
✓ APK in build/android/app/build/outputs/apk/debug

Install on a connected device:

adb install build/android/app/build/outputs/apk/debug/app-debug.apk

Launch the app. You should see device info populated.

7 · Use an internal plugin

The other 26 plugins (biometric, camera, face-verify, …) are SLM-internal and require a license:

# Add biometric to your spec:
# "plugins": ["device-info", "biometric"]

eximia build android
# Error: build refused: not authorized for: biometric.
# ○ Public mode (no license key set). Internal plugins require
# a valid SLM license. Set EXIMIA_LICENSE_KEY (online-verified at
# https://slmeximia.site/license/verify).

Get a license: email dev@slm.cloud with your customer name, plan, and plugin entitlements. Once you have a token:

export EXIMIA_LICENSE_KEY=<your-token>
eximia license status
# endpoint: https://slmeximia.site/license/verify
# ✓ SLM license active — customer=… plan=… (N plugins)

eximia build android
# → BUILD SUCCESSFUL

See Licensing for the full model + security properties.

8 · Build a release APK

eximia build android --release --signing-config path/to/signing.json

signing.json shape:

{
  "android": {
    "keystorePath": "/abs/path/to/release.jks",
    "keystoreAlias": "my-alias",
    "keystorePassword": "…",
    "keyPassword": "…"
  }
}

The CLI loads this, writes a keystore.properties, and Gradle signs the release APK with apksigner. Output:

build/android/app/build/outputs/apk/release/app-release.apk

Verify:

apksigner verify --verbose build/android/app/build/outputs/apk/release/app-release.apk

Where to go next

Plugin authoring — write your own plugins in Kotlin + Swift + JS.
Plugin manifest — every plugin.json field, what it does, and how the CLI consumes it.
Bridge contract — the JSON wire format between JS and native.
Licensing — public/internal split, online verification, and how to get a key.
Security model — what an Eximia app can and can't do at runtime.

Stuck? Email dev@slm.cloud with a description and eximia doctor output.