Quick answer: TensorFlow Lite is Google’s runtime for running trained machine learning models on phones, embedded devices and other hardware that cannot run a full server-sized model. It takes a model built in TensorFlow or another framework, converts it into a compact file, and executes it locally using whatever CPU, GPU or neural accelerator the device has. In September 2024 Google renamed the project LiteRT, short for Lite Runtime, to reflect that it now supports models from PyTorch and JAX as well as TensorFlow, but the underlying technology and the on-device job it does have not changed.
So where does that leave the name TensorFlow Lite? It is still how most people search for and refer to the technology, and it is still the name attached to years of existing apps, tutorials and documentation. This entry covers how the runtime actually works, what the LiteRT rename means in practice, where it shows up in real apps, how it compares with Apple’s Core ML, and where it runs into limits.
What Is TensorFlow Lite?
Google announced TensorFlow Lite in May 2017 as a lightweight counterpart to full TensorFlow, aimed specifically at mobile and embedded devices rather than servers. A developer preview followed later that year, and it grew into one of the most widely deployed on-device machine learning runtimes in the years after.
The core idea is conversion. A model trained with ordinary TensorFlow, or increasingly with PyTorch, JAX or Keras, gets converted into a .tflite file, a compact format built on FlatBuffers rather than the heavier format standard TensorFlow models use. That file is small enough to ship inside a mobile app and fast enough to run without a server round trip.
Why Was TensorFlow Lite Renamed to LiteRT?
Google made the rename official on September 4, 2024. By then the runtime had outgrown its own name: it converts and runs models authored in PyTorch, JAX and Keras as well as TensorFlow, so the TensorFlow half of the label no longer described what the project did.
LiteRT signals that multi-framework scope directly, letting a developer start with whichever framework they already use and still end up with the same on-device runtime. Existing apps built on TensorFlow Lite keep working without changes, and the rename mostly affects new projects choosing which package to install.
Fritz.ai’s own archive still refers to the technology as TensorFlow Lite, since most of that material predates the change. The APIs, the .tflite file format and the general approach it describes all still apply under the LiteRT name.
How Does TensorFlow Lite Work?
At the center of the runtime sits an interpreter that loads a .tflite model and runs its operations one by one. By default that happens on the CPU, but the interpreter can hand individual operations off to a delegate, a piece of code that runs the same math faster on the GPU, an NPU, or another specialized chip, while the interpreter still manages everything around it.
A newer CompiledModel API takes this further, handling acceleration across CPU, GPU and NPU behind a single interface instead of leaving a developer to select and wire up delegates by hand. Whichever path is used, models are typically shrunk first through quantization, converting the numbers inside a model to a lower precision, which cuts file size and speeds up inference with a small, usually acceptable, accuracy cost.
Getting to that .tflite file starts with a converter tool. A developer points it at a TensorFlow SavedModel or a Keras model, and it produces the FlatBuffer file the interpreter loads, optionally applying the same quantization step and attaching metadata that describes the model’s inputs and outputs so an app can call it correctly.
Where Is TensorFlow Lite Used?
The runtime powers machine learning features inside Google’s own apps, including Gmail, YouTube, Maps and Photos, running tasks like image and text processing directly on the user’s device. Google’s Coral hardware line, built around a dedicated Edge TPU chip first announced in 2018, was designed specifically to run TensorFlow Lite models at high speed in cameras and other embedded products.
Outside Google, the runtime shows up in Android apps that need a classifier, an object detector or a speech model to work instantly and offline, and in embedded and IoT products too constrained to run full TensorFlow. That work is what edge AI and on-device AI describe in the abstract, and this runtime is one of the most common ways it gets done in practice.
On Android it does not even have to ship with the app. Google distributes the runtime through Play services, so an app can call it rather than bundle its own copy, which keeps the download smaller and lets the runtime pick up performance improvements without the app being updated.
TensorFlow Lite vs Core ML: What’s the Difference?
Core ML is Apple’s equivalent runtime, built specifically for iPhone, iPad and Mac and tuned for Apple’s own Neural Engine. TensorFlow Lite, now LiteRT, aims wider: Android, iOS, desktop, the web through WebAssembly, and microcontrollers, all from one project.
That breadth is the main tradeoff. Core ML tends to integrate more tightly with Apple’s own tooling and frameworks for a developer who only targets Apple devices, while TensorFlow Lite is generally the choice for a team that needs the same model running on Android and iOS, or on hardware neither Apple nor Google makes.
What the two share is the conversion step, and neither one converts everything. A model that goes cleanly into .tflite can still hit an unsupported operation on the way into Core ML, or the reverse, so a cross-platform team ends up maintaining a separate conversion and test path for each target rather than one model file for both.
What Are the Limits of TensorFlow Lite?
Converting a model to .tflite is not always a clean, lossless step. Some operations, especially newer or unusual ones from a research model, are not supported by the converter and either block the conversion outright or force a developer to rewrite part of the model to work around it.
Quantization, the usual way to shrink a model for mobile, is a real accuracy tradeoff rather than a free win. A heavily quantized model can lose enough precision to matter on a sensitive task, which means teams generally have to test the converted model rather than assume it performs identically to the original.
The rename itself has created some short-term confusion. Documentation, tutorials and package names are gradually shifting from TensorFlow Lite to LiteRT, and a developer following an older guide may install a package or call an API that has since moved, without anything actually breaking on the runtime side.