# LiteRT Programming Languages: Complete Guide to Multi-Language Inference

> Explore LiteRT programming languages like C C++ Python JS Kotlin Java and Swift for seamless cross-platform on-device ML inference Unlock powerful AI capabilities.

- Repository: [google-ai-edge/LiteRT](https://github.com/google-ai-edge/LiteRT)
- Tags: tutorial
- Published: 2026-03-13

---

**LiteRT officially supports C, C++, Python, JavaScript/WebAssembly, Kotlin, Java, and Swift, providing stable APIs for cross-platform on-device machine learning inference.**

LiteRT (Lite Runtime) is a multi-language, cross-platform inference engine developed by Google AI Edge. The `google-ai-edge/LiteRT` repository ships official language bindings that enable developers to deploy machine learning models across mobile, web, and embedded environments using their preferred LiteRT programming languages.

## Official LiteRT Language Bindings

The repository provides first-class support for seven programming languages through distinct API layers:

- **C** – Stable ABI-compatible API for runtime, model building, and profiling
- **C++** – Public, non-ABI-stable API with convenient wrappers and RAII semantics
- **Python** – CPython extension exposing C and C++ APIs via `pybind11`
- **JavaScript / WebAssembly** – Wasm-based runtime for browsers and Node.js
- **Kotlin** – Android-focused wrapper forwarding calls to the C API via JNI
- **Java** – Android Java API built on top of the C runtime
- **Swift** – iOS/macOS Swift package wrapping the C/C++ APIs

Each binding targets specific deployment environments while sharing the same underlying inference engine.

## Language-Specific APIs and Implementation Details

### C API (Stable ABI)

The C API provides the foundational, ABI-stable interface defined in [`litert/c/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/c/litert_model.h). This layer offers the smallest binary footprint and serves as the canonical runtime interface for embedded and cross-language scenarios.

Key functions include `LiteRtCreateModelFromBuffer` for loading models, `LiteRtCreateRuntimeContext` for initialization, and `LiteRtCompiledModelExecute` for inference.

```c
#include "litert/c/litert_model.h"

int main() {
    // Load the model binary.
    const char *buf = /* read model.tflite into memory */;
    size_t size = /* size of the buffer */;
    LiteRtModel model = NULL;
    LiteRtStatus status = LiteRtCreateModelFromBuffer(buf, size, &model);
    if (status != kLiteRtStatusOk) return -1;

    // Create a runtime context.
    LiteRtRuntimeContext ctx = NULL;
    status = LiteRtCreateRuntimeContext(&ctx);
    if (status != kLiteRtStatusOk) return -1;

    // Build a compiled model for the default CPU.
    LiteRtCompiledModel compiled = NULL;
    LiteRtCompilerPlugin compiler = NULL;
    LiteRtCreateCompilerPlugin(&compiler);
    status = LiteRtCompilerPluginCompile(compiler,
                                         model,
                                         /*options=*/NULL,
                                         &compiled);
    if (status != kLiteRtStatusOk) return -1;

    // Execute the model (simplified).
    LiteRtExecutionContext exec_ctx = NULL;
    LiteRtCreateExecutionContext(&exec_ctx);
    LiteRtExecutionContextSetInput(exec_ctx, 0, /*input tensor*/);
    LiteRtCompiledModelExecute(compiled, exec_ctx);
    // Retrieve output, clean up …
}

```

### C++ API (Public Wrappers)

The C++ API in [`litert/cc/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/cc/litert_model.h) provides object-oriented wrappers with RAII semantics. While not ABI-stable, it offers a more convenient interface for native development.

The `litert::Model` class provides `CreateFromFile` for loading, while `litert::CompilerPlugin` handles model compilation.

```cpp
#include "litert/cc/litert_model.h"

int main() {
  // Load model from file.
  auto model = litert::Model::CreateFromFile("model.tflite");
  if (!model) return -1;

  // Build a compiled model for CPU.
  auto compiler = litert::CompilerPlugin::Create();
  auto compiled = compiler->Compile(*model);

  // Create an execution context.
  auto exec = compiled->CreateExecutionContext();
  exec->SetInput(/*tensor data*/);
  exec->Invoke();

  // Get output tensor.
  auto output = exec->GetOutput(/*index*/);
}

```

### Python API

The Python bindings are implemented in `litert/python/converter_wrapper.cc` using `pybind11` to expose the full C/C++ API. This enables rapid prototyping while maintaining the performance of the underlying engine.

```python
import litert

# Load model.

model = litert.load_model("model.tflite")

# Compile for the default device (CPU).

compiled = model.compile()

# Create an execution context.

exec_ctx = compiled.create_execution_context()
exec_ctx.set_input(0, input_tensor)   # NumPy array, for example

exec_ctx.invoke()

# Retrieve result.

output = exec_ctx.get_output(0)
print(output)

```

### JavaScript and WebAssembly

The JavaScript API loads a WebAssembly-based runtime defined in [`litert/js/packages/core/src/load_litert.ts`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/js/packages/core/src/load_litert.ts). This enables model execution in browsers and Node.js environments without requiring native installation.

```javascript
import { loadLiteRt } from '@litert/js';

// Load the runtime (Wasm) and the model binary.
async function run() {
  const litert = await loadLiteRt('litert_wasm_internal.js');
  const modelBytes = await fetch('model.tflite').then(r => r.arrayBuffer());

  const model = litert.createModelFromBuffer(new Uint8Array(modelBytes));
  const compiled = model.compile();               // CPU by default
  const exec = compiled.createExecutionContext();

  exec.setInput(0, new Float32Array([/* … */]));
  await exec.invoke();
  const output = exec.getOutput(0);
  console.log(output);
}
run();

```

### Kotlin (Android)

The Kotlin API in `litert/kotlin/` provides Android-focused wrappers that forward calls to the C API via JNI. These classes are generated from the Java binding but offer idiomatic Kotlin syntax.

```kotlin
import com.google.litert.LiteRtModel
import com.google.litert.LiteRtCompiledModel

// Load model from assets.
val assetManager = context.assets
val model = LiteRtModel.createFromAsset(assetManager, "model.tflite")

// Compile for default CPU.
val compiled: LiteRtCompiledModel = model.compile()

// Create execution context.
val exec = compiled.createExecutionContext()
exec.setInput(0, inputTensor)   // Tensor defined by LiteRtTensor
exec.invoke()

val output = exec.getOutput(0)

```

### Java (Android)

The Java API is defined in [`tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java). It provides a high-level Android interface built on top of the C runtime.

```java
import org.tensorflow.lite.Interpreter;

// Load the model.
Interpreter interpreter = new Interpreter(
        getAssets().openFd("model.tflite"));

// Prepare input and output buffers.
float[][] input = new float[1][224 * 224 * 3];
float[][] output = new float[1][1001];

// Run inference.
interpreter.run(input, output);

```

### Swift (iOS/macOS)

The Swift package is located in [`tflite/swift/Sources/Interpreter.swift`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/swift/Sources/Interpreter.swift). It wraps the C/C++ APIs for iOS and macOS development.

```swift
import TensorFlowLite

// Load model.
let interpreter = try Interpreter(modelPath: "model.tflite")

// Allocate tensors.
try interpreter.allocateTensors()

// Set input data.
var inputData = Data(...)
try interpreter.copy(inputData, toInputAt: 0)

// Run inference.
try interpreter.invoke()

// Get output.
let outputTensor = try interpreter.output(at: 0)
let results = [Float](unsafeData: outputTensor.data)   // Convert to Float array
print(results)

```

## Key Source Files and Entry Points

The following files define the primary entry points for each LiteRT programming language binding:

- **C**: [`litert/c/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/c/litert_model.h) – Stable ABI for model loading, compilation, and execution.
- **C++**: [`litert/cc/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/cc/litert_model.h) – Object-oriented wrappers with RAII semantics.
- **Python**: `litert/python/converter_wrapper.cc` – `pybind11` extension exposing the C/C++ API.
- **JavaScript / WebAssembly**: [`litert/js/packages/core/src/load_litert.ts`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/js/packages/core/src/load_litert.ts) – Wasm runtime loader for browsers and Node.js.
- **Kotlin**: `litert/kotlin/` – Android-specific Kotlin wrappers generated from Java bindings.
- **Java**: [`tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java) – High-level Android Java API.
- **Swift**: [`tflite/swift/Sources/Interpreter.swift`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/swift/Sources/Interpreter.swift) – Swift package for iOS and macOS.

These implementations collectively make LiteRT a **polyglot runtime**, enabling integration into native C/C++ projects, rapid prototyping in Python, web deployment via JavaScript/Wasm, and mobile embedding using Kotlin/Java (Android) or Swift (iOS).

## Summary

- LiteRT provides official language bindings for **C, C++, Python, JavaScript/WebAssembly, Kotlin, Java, and Swift**.
- The **C API** ([`litert/c/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/c/litert_model.h)) provides the stable ABI foundation used by all other language bindings.
- **C++** wrappers (`litert/cc/`) offer RAII semantics and object-oriented convenience while calling the C core.
- **Python** bindings use `pybind11` to expose the full C/C++ API for rapid prototyping.
- **JavaScript/WebAssembly** support enables browser-based inference via [`litert/js/packages/core/src/load_litert.ts`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/js/packages/core/src/load_litert.ts).
- **Kotlin** and **Java** APIs target Android development, with Kotlin providing modern Android syntax.
- **Swift** support delivers first-class iOS and macOS integration through the `tflite/swift/` package.

## Frequently Asked Questions

### What programming languages does LiteRT support?

LiteRT officially supports seven programming languages: C, C++, Python, JavaScript (via WebAssembly), Kotlin, Java, and Swift. These bindings enable deployment across embedded systems, desktop applications, web browsers, and mobile platforms including Android and iOS.

### Does LiteRT support WebAssembly for browser-based inference?

Yes, LiteRT provides a WebAssembly-based runtime accessible through JavaScript. The [`litert/js/packages/core/src/load_litert.ts`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/js/packages/core/src/load_litert.ts) module loads the Wasm binary, allowing models to execute directly in browsers and Node.js without native installation or platform-specific binaries.

### Which LiteRT API should I use for Android development?

For Android development, use the **Kotlin** API (`litert/kotlin/`) for modern Android applications, or the **Java** API ([`tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/java/src/main/java/org/tensorflow/lite/Interpreter.java)) for legacy support. Both APIs delegate to the underlying C runtime via JNI and provide high-level abstractions for model loading and inference.

### Is the LiteRT C API stable for long-term production use?

Yes, the C API defined in [`litert/c/litert_model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/c/litert_model.h) is designed as a stable, ABI-compatible interface. It serves as the canonical runtime foundation for all other language bindings and is intended for production use in embedded and cross-platform scenarios requiring long-term binary stability.