# tflite_flutter_plugin is deprecated, and the TensorFlow project it moved to is where to go > This repository was the original Flutter plugin for TensorFlow Lite, written in Dart and binding directly to the TFLite C API with NNAPI, GPU, Metal and CoreML delegates. It has been deprecated since April 2023 and is kept online for reference, with active development, issue triage and platform support moved to the TensorFlow-managed tensorflow/flutter-tflite repository. **am15h/tflite_flutter_plugin** — TensorFlow Lite Flutter Plugin - Repository: https://github.com/am15h/tflite_flutter_plugin - Website: https://pub.dev/packages/tflite_flutter - Stars: 540 · Forks: 359 - Language: Dart - License: Apache-2.0 - Published: 2026-10-22 · Updated: 2026-10-22 · Language: en - Canonical page: https://hysenlabs.com/projects/am15h-tflite-flutter-plugin ## The status section answers the first question The README opens its project status with a dated line, status refresh: May 2026, and then states the situation directly. This repository is deprecated and kept online for historical reference. Active package development, issue triage, and platform support for tflite_flutter now live in the TensorFlow-managed project. Three destinations are listed. The package is at pub.dev/packages/tflite_flutter, the repository is github.com/tensorflow/flutter-tflite, and the issues belong at github.com/tensorflow/flutter-tflite/issues. The README adds a routing instruction that is unusually specific: recent questions filed here, including iOS Swift Package Manager support and image preprocessing or helper APIs, should be tracked in the active TensorFlow repository so the maintainers of the current package see them. There is a docs/PROJECT_STATUS.md file referenced for migration and support routing notes. There is also an announcement section, dated 26 April 2023, that tells the same story from the other direction. The TensorFlow team officially migrated this project to a new repository, deprecating this one, with the focus on getting the plugin to a stable and usable state. So there are two deprecation markers about three years apart. The 2023 announcement records the migration. The 2026 status refresh records what the current state is, and it is the one to read first. The practical consequence is that this repository is now a reference implementation rather than a dependency you should add. The code, the install scripts, the examples and the wiki are all still there, and the API surface described below still tells you what the plugin does. But if you are picking a package today, the pub.dev entry for tflite_flutter and the tensorflow/flutter-tflite repository are the same maintained thing, and the difference is where you file your bug. ## What the plugin did: a direct binding to the TFLite C API The Overview section describes TensorFlow Lite Flutter plugin as providing a flexible and fast solution for accessing TensorFlow Lite interpreter and performing inference. Two details in it matter for anyone choosing between this and something else. The first is that the API is similar to the TFLite Java and Swift APIs. The plugin was not inventing an interface; it was mirroring the platform-native API so that a developer who had already written inference code for an Android app in Java, or an iOS app in Swift, would find the Dart version recognisable. The key features list repeats the point as a similar structure as the TensorFlow Lite Java API. The second is that it directly binds to TFLite C API, making it efficient with low latency. This is a Dart plugin over a C library, so the hot path crosses the FFI boundary rather than reimplementing inference in Dart, and the cost is that you need the native TensorFlow Lite binaries present on the device. The acceleration story is spelled out in the same paragraph. It offers acceleration support using NNAPI, GPU delegates on Android, Metal and CoreML delegates on iOS, and the XNNPack delegate on Desktop platforms. The key features list summarises it as acceleration using multi-threading and delegate support. Multi-platform support covers Android, iOS, Windows, Mac and Linux. Two further features are worth noting because they reflect design decisions rather than capability: you can choose to use any TensorFlow version by building the binaries locally, and you can run inference in different isolates to prevent jank in the UI thread. The isolate point is the one that matters for a Flutter application in particular. Dart is single-threaded per isolate, and a synchronous inference call blocks the UI. Running inference on a background isolate is the difference between a smooth app and a stuttering one, and this plugin was built with that in mind rather than leaving it to the caller. ## The install scripts are the awkward part of this plugin The section titled (Important) Initial setup : Add dynamic libraries to your app exists because a Flutter plugin cannot ship native libraries by itself the way an npm package can. For Android, the instructions are three steps. Place install.sh for Linux and Mac or install.bat for Windows at the root of your project. Execute sh install.sh or install.bat at the root of your project to automatically download and place binaries at appropriate folders. And then there is the flag, sh install.sh -d or install.bat -d, for the delegate-specific builds. The difference between the two builds is stated in a note. The binaries installed by default will not include support for GpuDelegateV2 and NnApiDelegate, however InterpreterOptions().useNnApiForAndroid can still be used. So the default binaries are the smaller ones, and the -d variant adds the two delegates that need extra native code. Those scripts install pre-built binaries based on the latest stable TensorFlow release, and the README points at the wiki for using other TensorFlow versions. The key features list puts it as you can choose to use any TensorFlow version by building binaries locally, which is the same capability seen from the other side. iOS is a manual download rather than a script. You download TensorFlowLiteC.framework, and place it in the pub-cache folder of the package, with the exact paths given for Linux and Mac at ~/.pub-cache/hosted/pub.dartlang.org/tflite_flutter-/ios/ and for Windows at %LOCALAPPDATA%\Pub\Cache\hosted\pub.dartlang.org\tflite_flutter-\ios\. Desktop follows a wiki guide on building desktop binaries with the XNNPack delegate. This is the real operational cost of the design. Anyone who has used a Flutter plugin that bundles its own native dependencies knows the pattern, and it is worth weighing: the setup is manual, it is per platform, and it is a step that a build pipeline has to reproduce. The plugin cannot be added to pubspec.yaml and forgotten about. ## The Dart API: import, asset, interpreter The usage section is short, and the API shape is the familiar one. The import is: ```dart import 'package:tflite_flutter/tflite_flutter.dart'; ``` Creating an interpreter from an asset: ```dart final interpreter = await tfl.Interpreter.fromAsset('your_model.tflite') ``` And the model has to be declared in pubspec.yaml, because the README's instruction for the asset case is to place your_model.tflite in the assets directory and make sure to include assets in pubspec.yaml. The flexibility point in the key features list is that you can use any TFLite model. There is no model zoo baked in, no format conversion, no label file handling. That is what the helper library is for. The TFLite Flutter Helper Library is described as a dedicated library with simple architecture for processing and manipulating input and output of TFLite Models, with an API design and documentation identical to the TensorFlow Lite Android Support Library. It is strongly recommended to be used with tflite_flutter_plugin and lives in its own repository at github.com/am15h/tflite_flutter_helper. That recommendation is the point. Image preprocessing is the tedious part of on-device inference, and the plugin deliberately leaves it to a companion package so that the interpreter stays a thin binding. The migration notes mention image preprocessing and helper APIs as one of the topics that should now be tracked in the active TensorFlow repository, which tells you where that work has continued. The examples table lists four applications, each with a code repository, a demo and a blog post where one exists: a text classification app, an image classification app, an object detection app, and a reinforcement learning app built on a board game. The reinforcement learning example is the most interesting of the four for what it implies about the plugin, since a policy evaluation loop calls inference many times per step and the isolate support is what makes that viable on a phone. ## Where the plugin's design falls short today The first limitation is the one that decided the deprecation: the native binaries are a manual step. Every developer on every platform has to run a shell script or a batch file before the plugin works, and the iOS path involves a zip download and a manual copy into a version-specific pub-cache path. Any change to the plugin version can therefore invalidate the framework you copied, and there is no mechanism in the repository to detect that. The second limitation is the split between the plugin and the helper. The plugin gives you an interpreter and the helper gives you preprocessing, and they are separate repositories with separate release cycles. The README's own advice, strongly recommended to be used with tflite_flutter_plugin, is a recommendation about version compatibility across two projects you now have to track. The third limitation is that this repository is a dead end for support. Questions that arrive here are answered by pointing elsewhere, and the two questions the README names as examples, iOS Swift Package Manager support and image preprocessing, are exactly the kind that need an active maintainer with a roadmap. The fourth limitation is the delegate story, which was always conditional on a build flag. If you want GpuDelegateV2 or NnApiDelegate, you do not use the default binaries. You use the -d variant, which is a separate download and a separate set of native libraries to keep in step with the app. That is a legitimate design for a plugin that cannot control its consumers' native toolchain, but it means acceleration is opt-in and versioned by hand. The alternative to weigh is not another Dart plugin but the maintained one. The tensorflow/flutter-tflite repository and the pub.dev package for tflite_flutter are where the same package name now lives, with the same feature list and the same delegate options, under a team rather than one author. The difference in approach between the two repositories is organisational rather than technical, and that is exactly the difference that matters for whether your issue gets fixed. There is a further alternative for a specific case. If you only need inference on one platform and do not need the Flutter API shape, calling the TFLite C API directly through your own FFI bindings removes the plugin's install step entirely, at the cost of writing the binding and the asset handling yourself. ## Licence, attribution and the shape of the release history The licence is Apache-2.0, recorded in the README badge and in the package metadata, with a LICENSE file at the repository root. That is a permissive grant with an explicit patent clause, and it means the code here can be reused and modified without copyleft obligations. That is a licensing note rather than legal advice, and it applies to the plugin code rather than to the TensorFlow Lite binaries it downloads, which carry their own terms. The attribution history is recorded in the announcement. The README thanks Amish for working on this initial plugin, and the announcement itself is signed with the contact address ptruiz@google.com and the note that the team is excited to keep it progressing. The repository owner name in the metadata reflects that origin, and the original author is still credited for the initial work. The release history shows what happened to the versioning. The tags are v0.9.0 in November 2021, then tf_2.5 in June 2021 and tf_2.4.1 in April 2021, which are the TensorFlow binary version tags rather than plugin version tags. So the last plugin version predates the migration by about a year and a half, and the binary tags stopped when the project moved. The last push to this repository was on 2026-05-31 and the repository is not archived, which is consistent with a repository being kept alive in a reference state rather than one being worked on. The live development is in the tensorflow/flutter-tflite repository, and the CHANGELOG.md here is where you would look for the history of what this code did before it moved. The repository layout confirms the scope of what is here. The platform directories android/, ios/, linux/, macos/ and windows/ are the plugin's native side, lib/ holds the Dart code, and example/ is a full Flutter application with its own pubspec.lock, integration_test/ and test_driver/ directories and its own install.sh. The install.sh at the repository root and the one in the example directory are the two entry points you would actually run. So if you find this repository through a search or through an old blog post, the useful thing to take from it is the model of how a Dart TensorFlow Lite binding is put together, including the parts that turned out to be awkward. The useful thing to install is the package from the maintained repository. ## Conclusion Adopt the tensorflow/flutter-tflite package rather than this repository, because the README states this one is deprecated and that package development, issue triage and platform support now live there, with the pub.dev package for tflite_flutter pointing at the same maintained code. Do not start new work against this repository even though the install scripts still work, since new questions such as iOS Swift Package Manager support are explicitly routed to the active project. Verify first which repository your pub.dev dependency actually resolves to, that the delegate you need is included in the binaries your install script downloads, and that the TensorFlow Lite version you build against matches the one in your app. ## FAQ ### Is the tflite_flutter_plugin deprecated? Yes. The README's status refresh from May 2026 states that the repository is deprecated and kept online for historical reference, and that active package development, issue triage and platform support for tflite_flutter now live in the TensorFlow-managed project at github.com/tensorflow/flutter-tflite. ### Which repository should I use for TensorFlow Lite in Flutter? The TensorFlow-managed one at github.com/tensorflow/flutter-tflite, with the package published at pub.dev/packages/tflite_flutter. The README lists those as the destinations for the package, the repository and the issue tracker, and the announcement records the official migration on 26 April 2023. ### How do I set up the native libraries for the tflite_flutter plugin? On Android, place install.sh for Linux and Mac or install.bat for Windows at the root of your project and run it to download and place the binaries automatically. On iOS, download TensorFlowLiteC.framework and place it in the pub-cache folder for the plugin version. Desktop follows a wiki guide on building binaries with the XNNPack delegate. ### What is the difference between install.sh and install.sh -d? The default binaries do not include support for GpuDelegateV2 and NnApiDelegate, although InterpreterOptions().useNnApiForAndroid can still be used. The -d variant is used instead if you want those two delegates, on Linux and Mac with sh install.sh -d and on Windows with install.bat -d. ### Which acceleration delegates does the tflite_flutter plugin support? The README lists NNAPI and GPU delegates on Android, Metal and CoreML delegates on iOS, and the XNNPack delegate on desktop platforms, alongside multi-threading. Inference can also be run in different isolates to prevent jank in the UI thread, and you can build the binaries locally against any TensorFlow version. ## Sources - [am15h/tflite_flutter_plugin on GitHub](https://github.com/am15h/tflite_flutter_plugin) - [License: Apache-2.0](https://github.com/am15h/tflite_flutter_plugin/blob/master/LICENSE) - [Project website](https://pub.dev/packages/tflite_flutter) - [README](https://github.com/am15h/tflite_flutter_plugin/blob/master/README.md) - [Releases](https://github.com/am15h/tflite_flutter_plugin/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/am15h-tflite-flutter-plugin