TensorFlow Lite Micro: Running ML Models on Microcontrollers and DSPs

The Gap TFLM Fills Between TFLite and Embedded Devices

TensorFlow Lite is designed for mobile and edge devices: smartphones, Raspberry Pi-class single-board computers, and other platforms that run a full Linux or Android stack with megabytes of RAM and a proper file system. Deploying TFLite on a microcontroller with tens of kilobytes of RAM and no operating system requires stripping the runtime down to its minimum viable inference kernel.

TensorFlow Lite for Microcontrollers (TFLM) is that stripped-down port. The README describes it as a port of TensorFlow Lite designed to run machine learning models on DSPs, microcontrollers, and other devices with limited memory. The project lives as a standalone repository separate from the main TensorFlow codebase, which reflects its distinct dependency profile and build requirements.

The target user is an embedded engineer or ML engineer working on a product where the inference device does not have the memory or compute to run a larger runtime. Applications include keyword spotting on a voice-enabled microcontroller, gesture recognition on a sensor node, and anomaly detection on a constrained industrial device.

What the Runtime Does and Does Not Include

TFLM is an inference-only runtime. It runs TFLite flat-buffer models that have been converted and optionally quantized for a target device. It does not include training, it does not support all TFLite operators, and it does not include the dynamic memory allocation patterns that the full TFLite runtime uses.

The memory management documentation (tensorflow/lite/micro/docs/memory_management.md) and the RFC for pre-allocated tensors reflect the project's core constraint: inference must work in a statically allocated arena without heap allocation, since microcontrollers often have no heap or a severely limited one.

The supported operator set is documented in the repository and is a subset of what the full TFLite runtime supports. Before porting a model, engineers must verify that every operator in their model appears in the TFLM supported ops list. The README links to the porting documentation for moving reference kernels from TFLite to TFLM when an operator is missing.

Compression support is documented at tensorflow/lite/micro/docs/compression.md, with a tutorial at tensorflow/lite/micro/compression/mnist_compression_tutorial.ipynb. This feature allows further reduction of model size on constrained devices beyond standard post-training quantization.

Supported Architectures and Community Platforms

The main CI tests run on four hardware architecture families: Cortex-M (Arm IP), RISC-V, Hexagon (Qualcomm DSP), and Xtensa (Cadence DSP). The README shows CI status badges for each. The core runtime targets are maintained by the TFLM team.

Beyond the core CI targets, the project maintains a community-supported platform table. The listed platforms are:

- Arduino: CI maintained by both tensorflow and antmicro - Espressif Systems dev boards: CI in espressif/tflite-micro-esp-examples - Coral Dev Board Micro (EdgeTPU): examples in google-coral/coralmicro - Texas Instruments dev boards: CI in TexasInstruments/tensorflow-lite-micro-examples - Silicon Labs Dev Kits: machine_learning_applications from SiliconLabsSoftware - Renesas boards: tflite-micro-renesas repository - Sparkfun Edge: community-maintained CI - Ingenic MIPS boards: community repository

The README page for new platform support is at tensorflow/lite/micro/docs/new_platform_support.md. Software emulation through both Renode and QEMU is documented for development workflows that do not require physical hardware.

Build System and Python Tooling

TFLM uses Bazel as its primary build system. The repository includes .bazelrc, .bazelversion, and a MODULE.bazel file. For embedded targets that cannot use Bazel, community platform examples typically use CMake or the target vendor's SDK build system.

The project also includes a Python interpreter for TFLM (python/tflite_micro/README.md). The Python interface allows running a TFLM model from Python code, which is useful for testing and validation of model behavior before flashing to hardware. The pyproject.toml at the repository root specifies Python 3.10 as the minimum target version:

[tool.ruff]
line-length = 80
target-version = "py310"

The tflite_micro.py script at the repository root provides the entry point for the Python interpreter. The documentation at docs/python.md covers the Python development guide in detail.

Continuous integration documentation is at docs/continuous_integration.md, and benchmark infrastructure is at tensorflow/lite/micro/benchmarks/README.md. The profiling documentation at tensorflow/lite/micro/docs/profiling.md covers how to measure operator execution time on target hardware.

Key Limitations for Embedded Deployments

Not all TFLite operators are supported. An engineer who trains a model using layers or operations not present in the TFLM supported op set must either change the model architecture, implement the missing kernel, or port the reference kernel from TFLite following the documentation at tensorflow/lite/micro/docs/porting_reference_ops.md.

The static arena memory model means model RAM usage must be measured and verified against the target device's available memory. The TFLM team provides profiling tools to measure peak arena usage, but the measurement must be done on the specific model and target combination; cross-device estimates are not reliable.

Mobile and server deployments should use the full TensorFlow Lite runtime or a higher-level serving framework. TFLM is not intended for and does not target those environments. The README makes this scope clear in its opening description: it is specifically for low-power, resource-constrained embedded targets including microcontrollers and digital signal processors.

The repository has no GitHub releases. Engineers adopt TFLM by including it as a submodule or copying the relevant source files into their embedded project's build system, following the new platform support documentation.

Comparison with ONNX Runtime for Edge, License, and Activity

ONNX Runtime is a cross-platform ML inference engine that also has an edge deployment variant (ONNX Runtime for Mobile). ONNX Runtime uses the ONNX model format, while TFLM uses TFLite flat-buffers. For embedded microcontrollers, TFLM is typically the more practical choice because it has direct support for bare-metal targets without an OS, whereas ONNX Runtime's embedded profile generally targets mobile-class devices with an OS.

For teams already in the TensorFlow ecosystem with existing TFLite models, TFLM is the natural inference path for microcontrollers. For teams using PyTorch, ONNX provides a conversion path, but the microcontroller deployment story is less mature than TFLM's on deeply embedded targets.

TFLM is published under the Apache-2.0 license, which allows commercial use, modification, and redistribution with attribution. The last push to the repository was on September 26, 2026. The SIG Micro group coordinates development through a mailing list at tensorflow.org and monthly meetings; the README links to both for contributors and adopters seeking support beyond GitHub issues.

Editorial conclusion

TensorFlow Lite Micro is the right choice when you need to run a TFLite-format model on a device that cannot run the full TensorFlow Lite runtime: a microcontroller, a DSP, or another resource-constrained embedded target. It is not appropriate for server, desktop, or mobile deployments where TFLite proper or a more capable inference runtime is available. Before adopting it, verify that your target architecture has CI support in the repository (Cortex-M, RISC-V, Hexagon, and Xtensa are covered), that your model's operators are in the supported operator set documented at tensorflow/lite/micro/docs/, and that your build system can integrate the Bazel or CMake-based build.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. README
4. tensorflow/tflite-micro on GitHub