What changed in LiteRT from 1 to 2

LiteRT Release Notes: Version 2.2.0

Executive Summary & Scope

API and Platform updates:

• Rust Integration - Published google-ai-edge-litert crate on crates.io enabling C++ SDK capabilities in Rust
• ABI Compatibility - Added ABI version tracking to key modules (libLiteRT.so, GPU accelerator, Dispatch, Compiler) facilitating smoother upgrades across 2.2.x binary versions. API Updates:
  • LiteRT.js - LiteRT Tensor API support and features for recurrent KV cache swapping; and JIT/tracing support for custom tensor graphs.
  • (check: do we call out SetSelectedSignatures?)
• New Data Type - Added native support for for F8E4M3FN and F8E5M2 tensor elements New HW support
• Intel NPU - Added full JIT/AOT support for LunarLake and Panther Lake
• Qualcomm - QAIRT : Improved SoC coverage with SDK 2.47
• MediaTek - Improvements to channelwise quantization support
• CPU (Experimental) : New YNNPack accelerator Performance and Model optimizations
• LLM throughput improvements - added ROPE composite Ops for GPU, resulting in ~5% faster decode performance
• Multiple optimizations for memory efficiency and GPU execution Validation / Testing Infrastructure
• Faster test registration
• New multi-criteria validation framework (ConformanceSpec) for mixed-precision verification.

🌟 Release 2.2.0 Summary

1. LiteRT Runtime

Overview: Core C/C++ inference engine, delegate interfaces, platform APIs (Swift, Python, C), memory management, and hardware acceleration plugins.

• Old Revision: v2.1.6
• New Revision: v2.2.0
• Repository: google-ai-edge/LiteRT

🤖 Model/ Operator Coverage

XNNPACK supports for fp16 DEPTHWISE_CONV_2D, CONV_2D, FULLY_CONNECTED, and BATCH_MATMUL ⚡ Performance and Memory

• Added a new precision mode, kLiteRtDelegatePrecisionFp16WithFp32Accum.Currently it is GPU only. When enabled the GPU backend will use FP16 storage and arithmetic with FP32 accumulation for CONV_2D, DEPTHWISE_CONV_2D, FULLY_CONNECTED, TRANSPOSE_CONV and BATCH_MAT_MUL operators , which can provide a midground between pure 32-bit and pure 16-bit computation.
• Prepares input on GPU for the models which don’t run embedding lookup on CPU, including Gemma3 or before, and Open weight models like Qwen3
• Added ROPE composite op for GPU to improve the performance for LLMs. The decode performance increased ~5%
• For best GPU performance, weights are re-arranged in batches on the GPU to be the optimal format for execution. In this release, the batch size was changed to scale with the total size of the model to reduce memory usage and improve initialization time. The impact will vary depending on model and device type but Gemma 4 E2B on a Linux NVIDIA machine saved ~200MB.

🛠️ Hardware Acceleration

• [Experimental] New CPU accelerator YNNPACK can be enabled through the compilation flag: --define litert_enable_ynnpack=true and runtime flag: --enable_ynnpack=true.
• Improved MTK NPU backend's channelwise quantization support for classical vision models, such as resnet18 and mobilenet.
• Added support for Intel NPU (LunarLake and PantherLake), enabling both JIT and AOT compilation. Verified on a variety of classic and selected GenAI models (Gemma4 2B instructions) on Windows and Linux.
• LiteRT QAIRT accelerator
  • Major Features and Improvements
    • Supported specifying the Qualcomm SoC using either the SoC name or numeric SoC model.
    • Aligned SoC coverage with QAIRT SDK 2.47.
    • Refined OP validation and debugging logs.
    • Added documentation for QNN Native Path, QC options, and CMake toolchain builds.
    • Improved compiler plugin to avoid redundant QNN library reloads.
    • Enhanced OP coverage: A8W2 Fully Connected, BatchToSpaceNd, and SpaceToBatchNd.
  • Bug Fixes and Other Changes - Skipped custom op delegates when the custom op package is not registered.

🔌 APIs & Platform support

• ABI version information has been added to data structures to enhance backward compatibility for data types used in interfaces between key LiteRT modules (libLiteRt.so, GPU Accelerators, Dispatch, Compiler). Once this compatibility feature is complete, the system will operate without issues even when using different 2.2.x version binaries together.
• The new LiteRT Rust binding has been open-sourced. The google-ai-edge-litert crate was published on crates.io and can be used with the standard Rust Cargo build manager. The binding is built on top of the LiteRT C++ Binary SDK.
• Introduced new SetSelectedSignatures API
• Added two new tensor element data type: F8E4M3FN and F8E5M2.
• LiteRt.js API added support for streamed weight loading Dynamic Range Quantized models to WebGPU.
• Tensor API:
  • Added RegisterCustomOpParser and MixinRegistrar to map custom flatbuffer operators (CUSTOM, STABLEHLO_COMPOSITE) to typed LiteRT operations and dynamically bind backend execution logic.
  • Added FeedbackLoopConfig to automate recurrent KV cache swapping and zero-copy buffer bindings between execution steps without requiring manual per-iteration re-binding.
  • Added Tensor API python support, extended with transformer operation surfaces, explicit Q/DQ export, quantized TFLite lowering, and Safetensors loading with compressed weight ingestion (qb4w).
  • Added JIT compilation and tracing support (compile() / WrittenModel) for authoring and executing custom tensor graphs directly in LiteRT JS.

🐛 Security, Vulnerability and Stability

• Added integer overflow checks to convolution, reshape and pad-like CPU kernels,
• Stricter input shape restriction in Conv3DTranspose: older versions of LiteRT also allowed this op’s number of output channels to be a multiple of the number of filter channels, but that this case was never implemented correctly and is no longer permitted.
• Fixed a transitivity violation in TopK comparator when NaN is present. NaNs are now treated as smaller than every non-NaN value, For example, for input [1, 2, 3, NaN] with k=3, the output should be [1,2,3].
• Enforced that the 1D size operand (operand 1) for ResizeBilinear and ResizeNearestNeighbor TFLite ops is dynamic or has dimension length 2
• Added initial fuzzing test based on https://github.com/google/fuzztest
• Accelerator Test Suite (ATS) improvements over all accelerator backends:
  • Expanded Operator & Subgraph coverage: Added test graph generators for Pad, Concatenation, Softmax, Transpose, BatchMatmul, FullyConnected, Reshape, Reduction, BinaryBroadcast, and OneHot, alongside a compound TransformerLayer generator built with the litert::tensor C++ API.
  • Advanced Conformance and Precision Verification: Introduced the ConformanceSpec multi-criteria validation framework (MSE, exact match, quantized buckets, accumulation tolerance), expanded FullyConnected quantization with dynamic/shuffled weights, and enabled FP16 and mixed-precision delegate testing.
  • Harness Performance and Infrastructure: Optimized test registration to be ~30x faster (reducing filter setup time from ~170s to ~6s), added full delegation hints for GPU/CPU to prevent premature validation errors, and lazily initialized test buffers to significantly reduce log noise during test execution.
• A fix was submitted that was preventing the GPU weight cache from being utilized.

Release 2.1.6

Major Features and Improvements

• Refactored CC APIs to be header only
• CC APIs now can be used without linking Abseil
• Released ARMv7 prebuilts
• Expanded Accelerator Test Suite (ATS) single op coverage to 43 ops across f16 and f32 data types.

Bug Fixes and Other Changes

• Improved built-in kernels to support high dimensional tensors, and fixed GPU kernel issues (like broadcast)

Release 2.1.5

Major Features and Improvements

• Python 3.14 Support: Added PyPI wheels for Python 3.14
• Make LiteRT C++ APIs header only
• Support LiteRT environment and option APIs directly from Python
• Removed libLiteRt.so dependency from GPU Accelerator and Dispatch API shared libraries. They no longer require libLiteRt.so to use.
  • Applied https://github.com/google-ai-edge/LiteRT/blob/main/g3doc/apis/runtime_context.md
• Made LiteRT Options class as pure data only object. It doesn’t require a LiteRT C API call to create & update the object.
• Added Raspberry Pi 5 GPU acceleration support

Bug Fixes and Other Changes

• Fixed GPU prebuilts for iOS devices https://github.com/google-ai-edge/LiteRT/issues/6745
• Fixed a bug on creating host memory TensorBuffer with alignment https://github.com/google-ai-edge/LiteRT/issues/5373

Release 2.1.4

Major Features and Improvements

• Improved c/cc API surfaces to avoid using deprecated methods
• Improved CMake build system’s build stability
• Introduced Environment to Python Compiled Model API to allow passing options

Release 2.1.3

Major Features and Improvements

• Updated CMake build rules to support both CompiledModel and Interpreter APIs.   cmake_example/CMakeLists.txt shows how you can use both libraries.

• Expanded MediaTek NPU support to all applicable Android versions   (only Android 15 previously) by supporting bundling MediaTek libraries in   application binary.

• Added experimental support for multi-threaded CompiledModel creation

• Fixed GPU support for Python on Windows

• Individual Options APIs (litert/cc/options) no longer use LiteRT C APIs (LiteRtXXX). They’re updated to use string based serialization and use LrtXXX() functions which can be linked individually.

• Added basic support for Broadcom VideoCore GPUs.

Bug Fixes and Other Changes

• Move the experimental API GetProfiler() out of litert::CompiledModel.

• Fixed a bug that given CPU Buffers are not always synced with GPU Accelerator   from the second inference.

• Removed methods from litert::Event which uses C type LiteRtEnvironment.   All C++ API should uses C++ litert::Environment instead.   Also removed method CreateFromSyncFenceFd() that doesn't accept   litert::Environment.

• Updated litert::Event::Type() to return C++ types instead of C types.

• The LiteRT headers no longer define the following OpenCL type names in the   global namespace when OpenCL is not supported: cl_mem, cl_event.   These have been replaced with the type aliases LiteRtClMem and   LiteRtClEvent, defined in a new header litert/c/litert_opencl_types.h.   All of these symbols that didn't include the LiteRt prefix in their name   were never intended to be part of the LiteRT API, and their presence   in the global namespace risked conflicts with header files from other   packages.

• Likewise, and for the same reason, the LiteRT headers no longer define the   following WebGPU type names in the global namespace when WebGPU is   supported: struct WGPUBufferImpl, WGPUBuffer. These have been   replaced with the type alias LiteRtWGPUBuffer which is defined in a   new header file litert/c/litert_webgpu_types.h. Alternatively, apps   using these symbols can get them from WebGPU's webgpu.h header file.

• Added experimental support for multi-threaded CompiledModel creation

Release 2.1.2

Major Features and Improvements

• Added Desktop GPU support in the ai-edge-litert Python package for Linux (through WebGPU) and Mac (through Metal).
• Released Windows ai-edge-litert Python package that supports CPU inference (WebGPU on Windows in Python is coming soon)

Release 2.1.1

Bug Fixes and Other Changes

• Fixed the MacOS wheel build issue
• Fixed the Qualcomm options passing issue in Kotlin API

Release 2.1.0

Release 2.1.0 is the LiteRT beta release.

LiteRT APIs are stable and have achieved feature parity. This milestone marks a significant step forward, introducing full feature parity with TensorFlow Lite, stable LiteRT APIs, and critical performance enhancements for GPU and NPU acceleration. With this release, we are officially recommending that developers begin their transition to LiteRT.

Major Features and Improvements

LiteRT Runtime

• Custom op is supported through custom op dispatcher.
• CMake Build is supported in addition to Bazel
• Released LiteRT C++ SDK using prebuilt libLiteRt.so file
• Added Profiler API in CompiledModel
• Added ErrorReporter API in CompiledModel
• Added ResizeInputTensor API in CompiledModel

LiteRT NPU

• Introduced LiteRT Accelerator Test Suite for coverage and regression testing
• Introduced LiteRT graph transformation APIs for compiler plugins
• Qualcomm
  • Added support for Qualcomm Snapdragon Gen5
  • Added support for NPU JIT mode
  • LiteRT Op coverage improvements
• MediaTek
  • Added support for NPU JIT mode
  • LiteRT Op coverage improvements

LiteRT GPU

• Increased GPU coverage with WebGPU/Dawn and OpenCL including Android, Linux, MacOS, Windows, iOS, IoT devices
• Added asynchronous execution to Metal, WebGPU backends
• Improved performance and memory footprint
• Added an option to control GPU inference priority
• Better error handling (without crashing) on Delegation errors

LLM Support

• Provided Desktop GPU backends prebuilt for Linux (x64, arm64), MacOS (arm64), Windows (x64)
• Improved memory utilization when executing on GPUs
• Published new LLMs on https://huggingface.co/litert-community
  • litert-community/FastVLM-0.5B
  • litert-community/Qwen3-0.6B
  • litert-community/embeddinggemma-300m with new NPU precompiled models
  • litert-community/gemma-3-270m-it with new NPU precompiled model
• Published Function Gemma on https://huggingface.co/google
  • google/functiongemma-270m-it

LiteRT on Android

• Added Interpreter API (CPU only) in the Maven v2.1.0+ packages
• Added Instruction to use pre-built CompiledModell C++ API from the Maven package.

Bug Fixes and Other Changes

Fixes Android min SDK version and it’s 23 now.

LiteRT NPU: Fixes partition algorithm when the full model cannot be offloaded to NPU.

Breaking Changes

• Removed direct C headers usage. Users no longer need to include C headers.
• TensorBuffer::CreateManaged() requires Environment always.
• All TensorBuffer creation requires Environment except HostMemory types.
• LiteRT C++ constructors are hidden. All LiteRT C++ objects should be created by Create() methods.
• Moved internal only C++ APIs(such as litert_logging.h) to litert/cc/internal
• Removed Tensor, Subgraph, Signature access from litert::Model. Instead users can access SimpleTensor, SimpleSignature.
• The CompiledModel::Create() API no longer needs litert::Model. They can be created from filename, model buffers directly.
• Users can access SimpleTensor and SimpleSignature from CompiledModel.
• Annotation, Metrics APIs are removed from CompiledModel.
• Removed individual OpaqueOptions creation. These OpaqueOptions objects are obtained by Options directly.
  • Options::GetCpuOptions()
  • Options::GetGpuOptions()
  • Options::GetRuntimeOptions()
  • …

Release 2.0.3

Major Features and Improvements

• Add Python backend for Google Tensor. The backend doesn't yet register itself, so it's available by default.
• Change manufacturer to Google and SoC models to include the Tensor_ prefix for Google Tensor.
• Minor naming changes to some flags for the Google Tensor compiler plugin.

Bug Fixes and Other Changes

• N/A