Exporting Ultralytics YOLO on LiteRT

At Ultralytics, we're seeing a growing shift toward running computer vision models directly on the devices where they're needed, rather than relying on a connection to the cloud. Mobile apps, embedded systems, IoT sensors, and browser-based tools increasingly need to run inference locally, often on hardware with tight power and compute budgets.That's why we're excited to announce that Ultralytics YOLO models can now be exported directly to LiteRT.

Meeting that demand calls for a model format that travels across all of these environments without forcing developers to maintain separate export pipelines for each one.

This capability existed before through an unofficial third-party package, but this new integration is the result of official collaboration with Google. We worked closely with the LiteRT team to build an end-to-end pipeline for exporting Ultralytics YOLO models to TFLite via LiteRT. With this integration, a single exported Ultralytics YOLO model deploys across mobile, embedded, edge, and browser environments, unifying what the older TFLite and TF.js export formats previously handled separately into one streamlined format.

Link to this sectionWhat is LiteRT?#

LiteRT (short for Lite Runtime) is Google’s high-performance runtime for on-device AI. It is the next generation and the new name for TensorFlow Lite (TFLite), and it runs the same .tflite model format developers already know.

LiteRT is an open-source framework designed specifically for on-device inference, also known as edge computing. It gives developers the tools to execute trained models on mobile, embedded, and IoT devices, traditional computers, and, through LiteRT.js, directly in web browsers and Node.js. The LiteRT export format optimizes models for tasks like object detection, segmentation, pose estimation, and classification so they run fast and offline across a wide range of devices.

Link to this sectionWhy export Ultralytics YOLO models to LiteRT?#

One model format now covers every deployment target:

• Mobile & embedded. Android, iOS, Desktop, embedded Linux, and microcontrollers (MCUs).

• Edge accelerators. Compatible with the Coral Edge TPU for further acceleration.

• Browser & Node.js. LiteRT.js runs the same .tflite model on the web with WebGPU/WASM acceleration, replacing the need for a separate TensorFlow.js export.

• Desktop

This consolidation matters because it removes a real source of friction in production deployments. Instead of maintaining one export pipeline for mobile, another for the browser, and a third for edge accelerators, teams can now export once and deploy everywhere LiteRT runs.

Link to this sectionKey features of LiteRT models#

• On-device optimization. Reduces latency by processing data locally, enhances privacy by not transmitting personal data, and minimizes model size to save space.

• Multiple platform support. Runs on Android, iOS, embedded Linux, microcontrollers, and modern web browsers.

• Hardware acceleration. Leverages XNNPACK on CPU, and GPU acceleration via OpenCL, Metal, and WebGPU. The GPU acceleration runs in FP16 by default for additional speed.

• Quantization. Supports FP32, static INT8, static INT16-activation, and dynamic INT8 to compress models and speed up inference with minimal accuracy loss.

• Diverse language support. Compatible with Java/Kotlin, Swift, Objective-C, C++, Python, and JavaScript.

Link to this sectionGetting started with LiteRT export#

The Ultralytics Python package and Ultralytics Platform provide a complete, unified environment for training, evaluating, and deploying YOLO models across all five computer vision tasks. The LiteRT export format supports Export, Predict, and Validate modes, so a model can be exported and then immediately used for inference or accuracy validation locally.

Exporting a model takes a single command:

from ultralytics import YOLO

\# Load a YOLO26 model
model \= YOLO("yolo26n.pt")

\# Export the model to LiteRT format
model.export(format="litert") \# creates 'yolo26n.tflite'

For teams deploying to constrained hardware, LiteRT also supports quantized export, allowing models to be compressed for faster inference with minimal accuracy loss:

from ultralytics import YOLO

model \= YOLO("yolo26n.pt")

\# Dynamic INT8: int8 weights, FP32 activations \- no calibration data needed
model.export(format="litert", quantize="w8a32")

\# Static INT8: int8 weights \+ int8 activations \- needs calibration data
model.export(format="litert", quantize=8, data="coco8.yaml")

Once exported, the model can be loaded and run for inference directly:

from ultralytics import YOLO

\# Load the exported LiteRT model
model \= YOLO("yolo26n.tflite")

\# Run inference
results \= model("https://ultralytics.com/images/bus.jpg")

LiteRT export is currently supported on Linux x86_64 and macOS. The exported .tflite model itself runs across every LiteRT-supported platform, including mobile, embedded, edge, and the browser.

Fig 1. Performance comparison between ONNX and LiteRT.

The image above features a comparison of mean inference time for detection, segmentation, and pose estimation on YOLO26n, running in the browser via @ultralytics/yolo, Ultralytics' npm package for client-side inference on WebGPU/WASM via ONNX Runtime Web. Benchmarked on a 2024 Apple MacBook Pro (Apple Silicon M4) in a controlled browser environment.

Link to this sectionBringing Ultralytics YOLO to the edge#

With LiteRT, deploying Ultralytics YOLO models across mobile, embedded, edge, and browser environments no longer requires separate export pipelines for each target. One export, one model format, and a consistent path from training to production, wherever inference needs to happen.

Curious about vision AI? Discover our licensing options to bring computer vision to your projects. Visit our GitHub repository to explore the full range of Ultralytics export integrations, and check out Ultralytics Platform to start building your own end-to-end vision AI workflows.