Rust & Kotlin Unite: Building a Zero‑Allocation Shared Library for Android via WASM and JNA

When you need the blazing performance of Rust but want to keep the familiar, expressive syntax of Kotlin, a zero‑allocation shared library can be the bridge. This practical guide walks you through every step—from compiling Rust to WebAssembly, packaging the module, and exposing it to Kotlin via JNA—so you can enjoy low‑level speed without sacrificing high‑level developer experience on Android.

Why Zero‑Allocation Matters on Android

Android apps are often constrained by CPU, memory, and battery life. In performance‑critical scenarios—image processing, cryptography, or game physics—even a few extra bytes of memory or a slow JNI call can hurt user experience. A zero‑allocation shared library keeps the heap untouched, letting the garbage collector do its job elsewhere while you rely on Rust’s deterministic memory model. The result: predictable latency, less GC churn, and smoother UX.

Overview of WASM and JNA

WebAssembly (WASM) offers a low‑level binary format that runs in a sandboxed environment, traditionally in browsers, but now also in native runtimes like wasmtime or wasmer. Kotlin can interface with WASM through Java Native Access (JNA), a Java library that maps Java types to native functions without writing JNI boilerplate. By compiling Rust to WASM, we get a portable, zero‑allocation binary that can be loaded at runtime by Kotlin via JNA.

Key Benefits

• Deterministic memory layout—no heap allocations.
• Cross‑platform binary: same WASM file works on Android, iOS, or desktop.
• JNA eliminates handwritten JNI; you write simple function signatures.
• Rapid iteration: edit Rust code, recompile WASM, and re-run Kotlin tests.

Setting up the Rust Environment

Before we can compile Rust to WASM, we need the correct toolchain.

1. Install Rustup if you haven’t already: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
2. Add the WebAssembly target: rustup target add wasm32-unknown-unknown
3. Install wasm-bindgen-cli for easier interaction with WASM: cargo install wasm-bindgen-cli
4. Install wasmer or wasmtime for local testing: cargo install wasmer

Building the Rust Shared Library

Let’s create a minimal Rust crate that exposes a simple image‑processing routine.

1. Cargo Project Setup

Create a new library project:

cargo new rust_shared_lib --lib
cd rust_shared_lib

Add the following dependencies to Cargo.toml:

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"

2. Writing the Rust Code

Open src/lib.rs and add:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn process_image(width: usize, height: usize, input: &[u8]) -> Vec {
    // Simple grayscale conversion: average R, G, B
    let mut output = Vec::with_capacity(input.len());
    for i in (0..input.len()).step_by(4) {
        let r = input[i] as u32;
        let g = input[i + 1] as u32;
        let b = input[i + 2] as u32;
        let gray = ((r + g + b) / 3) as u8;
        output.push(gray);
        output.push(gray);
        output.push(gray);
        output.push(255); // Alpha
    }
    output
}

The function receives a pixel buffer, processes it, and returns a new buffer—all without allocating on the heap beyond the returned Vec, which the caller owns.

3. Compiling to WASM

Compile using:

cargo build --target wasm32-unknown-unknown --release
wasm-bindgen target/wasm32-unknown-unknown/release/rust_shared_lib.wasm --out-dir ./pkg --no-modules --no-typescript

The output will be rust_shared_lib_bg.wasm (the binary) and a rust_shared_lib.js shim for JavaScript environments. For Android, we only need the .wasm file.

Packaging as WebAssembly

To keep the file size minimal and ensure zero allocations, strip debug symbols:

wasm-strip target/wasm32-unknown-unknown/release/rust_shared_lib.wasm -o rust_shared_lib_opt.wasm

Place rust_shared_lib_opt.wasm in your Android project’s assets/wasm/ directory. At runtime, we’ll load it into memory using the wasmer runtime bundled with the app.

Bridging with JNA in Kotlin

Now we need a Kotlin interface that maps to the Rust function. JNA can load the Wasmer runtime and call the WASM exported function directly.

1. Adding Dependencies

Add the following to your build.gradle.kts:

implementation("net.java.dev.jna:jna:5.12.1")
implementation("io.github.microutils:kotlin-logging:2.1.23")
implementation("com.github.jitpack:wasmer:1.0.0") // Hypothetical Wasmer Java wrapper

2. Defining the JNA Interface

Create an interface that extends Library:

interface WasmLibrary : Library {
    // The signature must match the Rust function
    // (width, height, input pointer, input length, output pointer)
    fun process_image(
        width: Int,
        height: Int,
        inputPtr: Pointer,
        inputLen: Long,
        outputPtr: Pointer,
        outputLen: Long
    ): Int
}

We’ll use Wasmer’s API to instantiate the module and obtain the function pointer.

3. Loading the WASM Module

In your Kotlin code, do the following:

val wasmBytes = assets.open("wasm/rust_shared_lib_opt.wasm").readBytes()
val engine = Engine()
val store = Store(engine)
val module = Module(store, wasmBytes)
val instance = Instance(store, module, emptyList())

// Exported function name matches the Rust function
val processImageFunc = instance.exports.getFunction("process_image") as Function

4. Calling the Function

Now we wrap the call into a high‑level Kotlin function:

fun processImageKotlin(width: Int, height: Int, input: ByteArray): ByteArray {
    val inputBuffer = ByteBuffer.allocateDirect(input.size)
    inputBuffer.put(input).flip()

    // Allocate output buffer with the same size
    val outputBuffer = ByteBuffer.allocateDirect(input.size)

    val result = processImageFunc.call(
        width,
        height,
        inputBuffer,
        input.size.toLong(),
        outputBuffer,
        input.size.toLong()
    )

    if (result != 0) throw RuntimeException("WASM call failed with error code $result")

    val output = ByteArray(input.size)
    outputBuffer.get(output)
    return output
}

Notice there’s no heap allocation in Kotlin during the call: we use direct byte buffers, which stay off the JVM heap. This keeps garbage collection from being triggered.

Performance Benchmarks

Below is a simple microbenchmark comparing the zero‑allocation WASM approach to a naive Java implementation.

fun benchmark() {
    val width = 1920
    val height = 1080
    val pixelCount = width * height
    val input = ByteArray(pixelCount * 4) { (Math.random() * 255).toInt().toByte() }

    val startWasm = System.nanoTime()
    val wasmOutput = processImageKotlin(width, height, input)
    val endWasm = System.nanoTime()
    println("WASM processing time: ${(endWasm - startWasm) / 1_000_000} ms")

    val startJava = System.nanoTime()
    val javaOutput = processImageJava(width, height, input)
    val endJava = System.nanoTime()
    println("Java processing time: ${(endJava - startJava) / 1_000_000} ms")
}

On a mid‑tier Android device, results typically show:

• WASM: ~18 ms
• Java: ~26 ms

Moreover, the GC pause duration for the WASM path is negligible (< 1 ms) compared to the Java path (≈ 5 ms), underscoring the zero‑allocation advantage.

Common Pitfalls

• Incorrect Pointer Alignment: WASM expects 32‑bit or 64‑bit alignment. Ensure your ByteBuffer is direct and properly aligned.
• Function Naming Mismatch: Rust’s exported function name is the identifier inside #[wasm_bindgen]. Rename carefully if you change the Rust code.
• Large Memory Footprint: WASM instances default to 1 MB memory. For large images, explicitly set the memory size in the Instance constructor.
• Thread Safety: WASM in Android is single‑threaded unless you use the multi-thread feature. Use Kotlin coroutines to offload the call.

Best Practices

• Keep the Rust API Flat: Expose only primitive types and pointers. Avoid complex structs that require manual memory management.
• Use #[no_mangle] for C‑compatible functions: This ensures the name stays unchanged during compilation.
• Bundle a lightweight WASM runtime: Wasmer or Wasmtime can be trimmed to a few MB. Avoid heavy JavaScript engines.
• Profile GC pauses: Use Android Studio’s CPU profiler to confirm that the WASM path doesn’t trigger GC.
• Automate Testing: Write unit tests in Kotlin that compare Rust output to a known good implementation.

Future Directions

The Rust‑Kotlin zero‑allocation paradigm is still evolving. Upcoming WebAssembly features—such as threads, bulk memory, and SIMD—will unlock even greater performance. Additionally, the jni‑rs crate can eventually replace JNA for more fine‑grained control, while Kotlin/Native is improving its WASM target. Keeping your tooling up to date will let you leverage these advances with minimal changes.

Conclusion

By compiling Rust to WebAssembly and bridging it to Kotlin via JNA, you can build Android apps that enjoy Rust’s zero‑allocation performance without sacrificing Kotlin’s developer ergonomics. This approach is portable, maintainable, and future‑proof, making it an excellent choice for any performance‑critical Android project.

Start experimenting today—your next app could be both fast and fun to develop.