Edge AI / model serving · SDK

LiteRT

Google

Run machine-learning inference on supported devices.

Official documentation Download development spec

GOOGLE LITERT / DEVELOPER FIELD GUIDE

Choose an interface. Define a verifiable result.

Company or project context, ten technical entry points and a practical analysis of every reference.

2026-10-08 · Integration not tested

Company / project overview

Original summary of official company or project statements; use the source for the full original page.

Google LiteRT · About
Project	LiteRT is Google’s on-device model deployment framework, built on TensorFlow Lite.
Scope	Covers model conversion, optimization and runtime execution across supported edge platforms.
Runtime choices	Current documentation distinguishes CompiledModel from the compatibility-oriented Interpreter path.
Adjacent product	LiteRT-LM adds language-model orchestration; it is a separate integration choice from this tensor inference example.

Complete official About page ↗

About reference — TA analysis
Audience	Buyers, partners and product owners shortlisting an AI provider.
Our assessment	Use positioning and company history for initial fit. Obtain project-specific deployment, support and commercial terms separately.

Official project and developer sources reviewed; no provider API was called. Expected outputs below are our illustrative contracts, not measured results.

Top 10 technical entry points

Ten documented technical entry points, selected by task; not ten independent SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · CompiledModel quickstartAPI / SDK / developer guide	Prepare a model and use the on-device runtime.ML application developers
02 · Android integrationAPI / SDK / developer guide	Select an Android runtime integration path.Android application teams
03 · NPU accelerationAPI / SDK / developer guide	Configure supported NPU execution.Hardware optimization teams
04 · Model conversionAPI / SDK / developer guide	Convert supported source models for LiteRT.Model export engineers
05 · TensorFlow Lite migrationAPI / SDK / developer guide	Review the supported migration paths to LiteRT.Existing TFLite maintainers
06 · Model optimizationAPI / SDK / developer guide	Review optimization including post-training quantization.Model efficiency engineers
07 · LiteRT CLI installationAPI / SDK / developer guide	Install command-line model tooling.Build and tooling teams
08 · Microcontroller runtimeAPI / SDK / developer guide	Run suitable small models in constrained environments.Embedded firmware teams
09 · Prebuilt C++ SDKAPI / SDK / developer guide	Integrate prebuilt runtime libraries with CMake.Native application developers
10 · Source and release repositoryAPI / SDK / developer guide	Inspect source, releases and project build entry points.Runtime maintainers

Reference analysis

Capabilities summarize official documentation. Constraints and proposed tests are our engineering assessment.

API / SDK / developer guide

CompiledModel quickstart

CompiledModel quickstart · TA
Target audience	ML application developers
Documented capability	Prepare a model and use the on-device runtime.
Input → output	Compatible model and input tensors → output tensors.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Output meaning comes from the model, not the runtime alone.
Our suggested validation	Verify shapes, types and model-specific postprocessing.

Official reference · CompiledModel quickstart ↗

API / SDK / developer guide

Android integration

Android integration · TA
Target audience	Android application teams
Documented capability	Select an Android runtime integration path.
Input → output	Model, app and SDK configuration → device inference.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	API availability depends on the selected distribution and device.
Our suggested validation	Test lifecycle and memory on the actual minimum target device.

Official reference · Android integration ↗

API / SDK / developer guide

NPU acceleration

NPU acceleration · TA
Target audience	Hardware optimization teams
Documented capability	Configure supported NPU execution.
Input → output	Compatible graph and hardware → accelerated execution.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Not every operator or chip supports the same path.
Our suggested validation	Record actual backend and compare numerical results to baseline.

Official reference · NPU acceleration ↗

API / SDK / developer guide

Model conversion

Model conversion · TA
Target audience	Model export engineers
Documented capability	Convert supported source models for LiteRT.
Input → output	Source model → .tflite artifact.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	A successful export does not prove task quality.
Our suggested validation	Compare source and exported model on held-out inputs.

Official reference · Model conversion ↗

API / SDK / developer guide

TensorFlow Lite migration

TensorFlow Lite migration · TA
Target audience	Existing TFLite maintainers
Documented capability	Review the supported migration paths to LiteRT.
Input → output	Existing integration → selected updated runtime path.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Interpreter compatibility and CompiledModel adoption are different changes.
Our suggested validation	Pin old and new dependencies and replay the same fixtures.

Official reference · TensorFlow Lite migration ↗

API / SDK / developer guide

Model optimization

Model optimization · TA
Target audience	Model efficiency engineers
Documented capability	Review optimization including post-training quantization.
Input → output	Model and optional representative data → optimized artifact.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Quantization can change accuracy and tensor types.
Our suggested validation	Measure quality drift before accepting any size or speed gain.

Official reference · Model optimization ↗

API / SDK / developer guide

LiteRT CLI installation

LiteRT CLI installation · TA
Target audience	Build and tooling teams
Documented capability	Install command-line model tooling.
Input → output	Supported environment and package → available CLI.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Pin the tool version; installation alone is not deployment.
Our suggested validation	Record version and validate the chosen command on a fixture.

Official reference · LiteRT CLI installation ↗

API / SDK / developer guide

Microcontroller runtime

Microcontroller runtime · TA
Target audience	Embedded firmware teams
Documented capability	Run suitable small models in constrained environments.
Input → output	Supported model and firmware tensors → inference output.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Memory and supported operations differ from desktop runtime.
Our suggested validation	Check tensor memory budget and target-board outputs.

Official reference · Microcontroller runtime ↗

API / SDK / developer guide

Prebuilt C++ SDK

Prebuilt C++ SDK · TA
Target audience	Native application developers
Documented capability	Integrate prebuilt runtime libraries with CMake.
Input → output	Headers, libraries and model → native integration.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Runtime and accelerator binaries must match platform and version.
Our suggested validation	Verify loading and packaged dependencies on a clean target.

Official reference · Prebuilt C++ SDK ↗

API / SDK / developer guide

Source and release repository

Source and release repository · TA
Target audience	Runtime maintainers
Documented capability	Inspect source, releases and project build entry points.
Input → output	Pinned source revision → reproducible build inputs.
Execution environment	Selected LiteRT runtime and supported target hardware
Our decision constraint	Repository head can differ from installed stable packages.
Our suggested validation	Record the exact tag or commit with build options.

Official reference · Source and release repository ↗

Official documentation overview

Official documentation overview · Supporting reference analysis
TA	Developers and product owners selecting the supported technical path.
Our validation advice	Choose the operation, supported version and runtime before assigning implementation.

Official reference · Official documentation overview ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Illustrative tensor inference contract. Tensor shape, dtype, normalization and labels must come from the actual model; no inference or benchmark was run.

Illustrative contract · no API call or model execution · not measured provider output

Valid inference contract

Expected behavior — illustrative, not executed
Input	Pinned model; tensor shape and type match its signature.
Expected result	ok; output tensor metadata and illustrative values.
Acceptance	Compare to a trusted model fixture using agreed tolerances.

Empty application result

Expected behavior — illustrative, not executed
Input	A valid inference whose model-specific postprocessor finds no detections.
Expected result	ok with an empty detection list; raw tensors still follow the model.
Acceptance	Do not treat an all-zero tensor as universally equivalent to no detections.

Tensor mismatch

Expected behavior — illustrative, not executed
Input	Wrong dtype, shape or unsupported operation.
Expected result	error; no usable output; include a bounded diagnostic.
Acceptance	Reject the input rather than silently reshaping its meaning.

Accelerator unavailable

Expected behavior — illustrative, not executed
Input	Requested GPU/NPU cannot execute the selected model.
Expected result	Explicit failure or a configured CPU fallback with actual backend disclosed.
Acceptance	Do not claim GPU/NPU acceleration or measured latency without evidence.

Map the expected result to your application

Review the scenarios below and map the actual SDK response into this internal contract. No credential, API call or live output is included. Replace example data only after your own integration test.

Expected output JSON — illustrative, not measured · LiteRT-expected-results.json

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "Google LiteRT",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "model_id": "example-model",
    "backend": "example-cpu",
    "outputs": [
      {
        "name": "example_scores",
        "shape": [
          1,
          3
        ],
        "dtype": "float32",
        "values": [
          [
            0.1,
            0.7,
            0.2
          ]
        ]
      }
    ],
    "latency_ms": null
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Result states	ok means the selected operation returned a valid result; a valid empty result differs from error. Pending work remains pending until a terminal result. Do not infer real-world correctness from API success.
Reproducibility	Record input ID, library/model version, configuration, runtime and coordinate/score conventions. Examples contain invented sample values.
Acceptance — proposed	Use representative authorized samples plus empty, malformed and unavailable-runtime cases. Agree quality and latency targets before running tests. No measured accuracy, cost or speed is claimed.
Operation boundary	Illustrative tensor inference contract. Tensor shape, dtype, normalization and labels must come from the actual model; no inference or benchmark was run.

Related route to assess: ONNX Runtime

Development assessment

Mobile inference benchmark

Development concept · integration not tested

Provider capabilities above are based on official documentation or repositories. The proposed product, inputs, deliverable and acceptance criteria below are our development assessment.

Integration pilot

Validate runtime, schemas or hardware together before estimating a deployable product.

Proposed inputs: One pinned model, representative inputs, target runtime and workload.
Proposed deliverable: Predictions or deployment evidence with model version, latency and resource measurements.
Acceptance criterion: Verify outputs against a known sample and measure latency, memory and failed calls on the chosen target.
Dependencies: Model rights, supported operators, memory budget and hardware or serving infrastructure.

Development sequence

Confirm access to LiteRT, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Mobile inference benchmark”.
Normalize the result with source, time and explicit error state; keep the provider response for review.
Run the acceptance criterion before estimating rollout effort or committing a customer deliverable.

How to validate demand

Record product views, documentation clicks, specification downloads and contextual hub clicks. These are event counts, not unique people or completed integrations.

This feasibility assessment uses implementation conditions. No traffic-based rank or delivery-time promise is assigned.

LiteRT

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

Official documentation overview

Expected results before implementation

Valid inference contract

Empty application result

Tensor mismatch

Accelerator unavailable

Map the expected result to your application

Mobile inference benchmark

Development sequence

How to validate demand

Related products