Flutter AR Plugins in 2026: 7 Packages Screened Before a Device Test

TL;DR

• Seven Flutter AR packages from pub.dev, read in October 2026. No builds and no device runs.
• Three track faces only. Four wrap ARKit or ARCore and track the room, and three of those four also expose a face mode.
• None of the seven gives you face tracking in a Flutter web build.
• deepar_flutter is DeepAR's own package, last uploaded in January 2023, and its permission_handler pin clashes with apps already on version 11 or newer.
• The ML Kit face mesh package carries an iOS tag on pub.dev, while its README says Android only.

Flutter AR always runs in native code. ARKit, ARCore, Google's ML Kit or a vendor SDK does the tracking, and the Dart package you add to pubspec.yaml is the bridge to it, so choosing a Flutter AR package mostly means choosing which native engine you inherit and how much setup it leaves on your desk.

I screen for that before any package earns time on a phone. This post is the screen for seven packages, run as five numbered checks. The native SDKs underneath are a separate question, and I went through six of those from their own documentation in 6 face AR SDKs compared by what their docs publish.

How I ran this screen

Sources for this round, read in October 2026: each package's pub.dev listing (version, upload date, publisher, license, platform tags, dependencies), its README, and the API reference where the README was thin. For two native face SDKs that skip pub.dev, Agora's integration guide and each vendor's own site.

Nothing was built, installed or run for this post, so it carries no device model, OS version, chipset or frame time. It is a filter that decides what deserves device time, and the device round is a separate post.

One rule for this round was self-serve only. A package qualified if a developer can install it and initialize it without talking to a salesperson. DeepAR's license keys come from a project you create on its developer site, so it qualified. Three vendor SDKs did not, and they are at the end.

If one of these facts ends up deciding your build, confirm it with the publisher in writing, because a pub.dev listing changes with every upload.

The seven packages

Four wrap a platform AR framework and are built around the room: ar_flutter_plugin_plus, arkit_plugin, arcore_flutter_plugin and augen.

Three track faces only: google_mlkit_face_detection, google_mlkit_face_mesh_detection and deepar_flutter.

Check 1: does the package track a face, or the room around you?

This is the split people skip, and it decides how much rendering code you write.

ar_flutter_plugin_plus wraps ARKit on iOS and ARCore on Android. Its eight example apps cover debug options, local and online objects, anchors on planes, transformation gestures, screenshots, cloud anchors, external model management and image tracking. None of the eight is a face sample, so treat it as a world-tracking package.

arkit_plugin wraps ARKit and lists a Face Tracking example, described as a face mask sample, next to plane detection, image detection and body tracking.

arcore_flutter_plugin wraps ARCore on Android and ships an ArCoreFaceView widget. Its enableAugmentedFaces flag defaults to false, so face mode is something you switch on.

augen wraps ARCore on Android and RealityKit with ARKit on iOS. Its feature list puts face tracking "with facial landmarks and expressions" beside plane detection, image tracking, cloud anchors and physics.

The other three only do faces, and they split again. google_mlkit_face_detection returns a bounding box, head rotation angles, landmarks for the mouth, ears, eyes, cheeks and nose, a smile probability when classification is on, and a tracking ID when tracking is on. google_mlkit_face_mesh_detection returns a 468-point 3D mesh. Both hand geometry back to Dart, and drawing an effect on top of it is your job.

deepar_flutter sits at the other end. Its feature list is live AR preview, screenshots, video recording, camera flip and flash, so the vendor's renderer draws the effect and you place a preview widget.

Here is the ML Kit side in practice, adapted from the face mesh package's README:

// FaceMeshDetector and FaceMesh come from google_mlkit_face_mesh_detection.
// inputImage: one camera frame wrapped as an InputImage (google_mlkit_commons).
Future<void> readFaceMesh(InputImage inputImage) async {
  final meshDetector =
      FaceMeshDetector(option: FaceMeshDetectorOptions.faceMesh);
  final List<FaceMesh> meshes = await meshDetector.processImage(inputImage);
  for (final FaceMesh mesh in meshes) {
    final points = mesh.points;       // the 468 3D points
    final triangles = mesh.triangles; // topology for your own renderer
  }
  meshDetector.close();
}

Every point and triangle in that loop is input for a painter or shader you still have to write.

One number to keep straight if you are comparing docs: ML Kit's face mesh returns 468 points, while Google's MediaPipe Face Landmarker returns 478. They are different products from the same company, and the counts are not a typo in either place.

Check 2: who publishes it, under which license, and when did it last ship?

pub.dev shows a verified publisher as a domain next to the package name. Six of the seven have one:

• ar_flutter_plugin_plus: xinix.tech, version 1.1.3, uploaded 28 January 2026. It is a fork of Lars Carius's original ar_flutter_plugin, whose newest release, 0.7.3, dates from 19 November 2022.
• arkit_plugin: leushchenko.com, version 1.5.0, uploaded 3 August 2026.
• arcore_flutter_plugin: gdifrancesco.dev, version 0.1.0, uploaded 7 February 2023, plus a 0.2.0-alpha prerelease from 20 February 2023.
• google_mlkit_face_detection 0.15.1 and google_mlkit_face_mesh_detection 0.6.1: flutter-ml.dev, both uploaded 17 August 2026. Both READMEs state that the plugin is "not sponsored or maintained by Google".
• deepar_flutter: deepar.ai, version 0.0.5, uploaded 29 January 2023.

augen is the one unverified uploader in the set, and also the newest upload, version 1.5.0 from 1 October 2026.

All seven list MIT on pub.dev. That license covers the bridge code in each package. The engine underneath is a separate dependency, and DeepAR's will not initialize without a license key for each platform.

Does DeepAR support Flutter?

Yes, through a package DeepAR publishes itself. pub.dev lists deepar_flutter under the verified publisher deepar.ai with the description "Official Flutter SDK for DeepAR", for Android SDK 23+ and iOS 13.0+. The catch is age: 0.0.5, uploaded 29 January 2023, is the newest of its five versions.

The confusion has a source. DeepAR's documentation, as it read on 17 October 2026, names four supported platforms (iOS, macOS, Android and Web) and has no Flutter page, so research that stops at the docs comes back with the wrong answer.

The age shows up in the dependency list. deepar_flutter 0.0.5 depends on permission_handler ^10.0.0, which in Dart's caret syntax means any version from 10.0.0 up to, but not including, 11.0.0. If your app or another package in it needs permission_handler 11 or newer, pub cannot resolve both without a dependency_overrides entry, and the same Dart page warns that overriding outside a package's declared range "might break your application". ar_flutter_plugin_plus 1.1.3, for example, asks for permission_handler ^12.0.1, so those two packages cannot sit in one pubspec without an override.

Access is self-serve. You create a project on DeepAR's developer site and generate the keys there. The native SDK is free for development and testing with a watermark. DeepAR's pricing page, last checked on 17 October 2026, listed free use up to 10 monthly active users, paid tiers from $25 a month for up to 1,000 MAU to $1,000 a month for up to 100,000 MAU, and sales above that. Treat those figures as approximate, not a quote.

Check 3: does the pub.dev platform tag match what actually works?

Read the tags and the README together, because they do not always agree.

google_mlkit_face_mesh_detection is tagged Android and iOS. Its README opens with a note that the feature "is still in Beta, and it is only available for Android".

augen is tagged Android, iOS and web. Its web table shows marker tracking from PNG or JPG templates working in the browser, while face tracking, plane detection and cloud anchors are marked "Mobile only". On iOS it adds one more limit: RealityKit cannot read GLTF or GLB, so those models render as an orange placeholder box and the README tells you to ship USDZ for iOS.

arkit_plugin is iOS only, and its FAQ answers the Android question with "No, as ARKit is not available on Android". arcore_flutter_plugin is Android only.

google_mlkit_face_detection covers Android and iOS, and its README states that web "or any other platform is not supported". deepar_flutter lists "Android & iOS", even though DeepAR's native SDK also runs on the web.

Put together, none of the seven gives a Flutter web build face tracking.

Can I use ML Kit face mesh detection on iOS in Flutter?

Not with google_mlkit_face_mesh_detection 0.6.1, whose README limits the feature to Android while it is in Beta. On iOS the closest option in this set is google_mlkit_face_detection, which gives you contours and landmarks but no 468-point mesh.

Check 4: what do you set up outside pubspec.yaml?

None of the following happens on flutter pub get, so it belongs in the estimate.

deepar_flutter on Android needs compileSdkVersion 33 or more and minSdkVersion 23 or more, plus the native library itself: you download it from DeepAR and place it at android/app/libs/deepar.aar. Its README adds ProGuard keep rules, "else app might crash in release build". On iOS it wants a 13.0 deployment target and Podfile preprocessor definitions for camera and microphone permissions.

google_mlkit_face_detection on iOS needs a 15.5 minimum deployment target, Xcode 15.3.0 or newer, and armv7 excluded in Xcode, because ML Kit supports 64-bit architectures only.

augen on Android declares android.hardware.camera.ar as required and sets the com.google.ar.core meta-data to required, with minSdkVersion 24. On iOS it needs NSCameraUsageDescription, arkit under UIRequiredDeviceCapabilities, and a 13.0 deployment target. It also asks for Dart 3.9.2 or newer, which matters if your app is pinned to an older toolchain.

How do I turn on face tracking in arkit_plugin?

You opt in, because the TrueDepth and face tracking code is not compiled in by default. On Flutter 3.44 and later, which builds plugins with Swift Package Manager, add this key to ios/Runner/Info.plist:

<key>ARKitFaceTrackingEnabled</key>
<true/>

Then clear the SwiftPM manifest cache and DerivedData:

rm -rf ~/Library/Caches/org.swift.swiftpm/manifests
rm -rf ~/Library/Developer/Xcode/DerivedData

The README is explicit that flutter clean and Xcode's Clean Build Folder are not enough on their own, because SwiftPM caches the evaluated Package.swift.

If your repository does not put Info.plist where the plugin expects it, which is the normal situation in a monorepo, the README gives an environment variable instead: set ARKIT_FACE_TRACKING_ENABLED=1, with export for terminal builds and launchctl setenv for builds started from the Xcode GUI.

On older Flutter versions that still build with CocoaPods, the same switch is a post_install block in ios/Podfile that adds -DENABLE_TRUEDEPTH_API to OTHER_SWIFT_FLAGS on the arkit_plugin target. If you have set up SPM, skip the Podfile step.

Why is ARCore tracking choppy in my debug build?

ar_flutter_plugin_plus warns about a bug in the ARCore library that interferes with tracking on some Android devices, and its workaround is to build with debuggable false in build.gradle. The README links the ARCore issue on GitHub. If tracking only looks rough in debug, rule that out before you blame the plugin. Its suggested Podfile also raises the iOS deployment target to 15.0.

"can only be launched from Flutter tooling" on an iOS debug build

augen's troubleshooting section covers this one: debug builds must be started by flutter run or Xcode, not from the home screen. If flutter run hangs waiting for the VM Service, it suggests closing Xcode and running flutter config --enable-lldb-debugging, or using flutter run --release.

Check 5: what does the phone have to have?

arkit_plugin notes that ARKit needs an A9 or later processor (iPhone 6s/7/SE/8/X, iPad 2017/Pro) on iOS 11 or newer, that some features need iOS 12, and that the plugin's own minimum is iOS 13.0. For faces, augen's iOS table maps face tracking to ARFaceTrackingConfiguration on the TrueDepth front camera.

On Android, augen's troubleshooting list starts with two device checks that apply to every ARCore wrapper here: the device has to support ARCore, and Google Play Services for AR has to be installed.

The ML Kit face mesh wants faces within about 2 meters of the camera, facing it, with at least half of the face visible. On iOS, ML Kit runs on 64-bit devices only.

deepar_flutter sets its floor at Android SDK 23 and iOS 13.0.

For arcore_flutter_plugin I read the versions list and the API reference only, so it has the thinnest entry in this post. That reflects my reading list and says nothing about the package's quality.

The seven side by side

Package	Tracks	Publisher on pub.dev	Version I read (upload date)	Platforms that work	Setup to plan for	Access
ar_flutter_plugin_plus	Planes, anchors, images, cloud anchors	xinix.tech (verified)	1.1.3 (28 Jan 2026)	Android, iOS	debuggable false for the ARCore bug, iOS 15.0 in Podfile	Open, MIT
arkit_plugin	World, face (opt-in), body	leushchenko.com (verified)	1.5.0 (3 Aug 2026)	iOS	TrueDepth flag plus SwiftPM cache clear	Open, MIT
arcore_flutter_plugin	World, Augmented Faces	gdifrancesco.dev (verified)	0.1.0 (7 Feb 2023)	Android	enableAugmentedFaces: true	Open, MIT
augen	World, images, face	Unverified uploader	1.5.0 (1 Oct 2026)	Android, iOS; web for markers only	ARCore required in manifest, USDZ on iOS, Dart 3.9.2+	Open, MIT
google_mlkit_face_detection	Face box, landmarks, contours	flutter-ml.dev (verified)	0.15.1 (17 Aug 2026)	Android, iOS	iOS 15.5, exclude armv7	Open, MIT
google_mlkit_face_mesh_detection	468-point face mesh	flutter-ml.dev (verified)	0.6.1 (17 Aug 2026)	Android only, despite the iOS tag	minSdkVersion 21	Open, MIT
deepar_flutter	Face, with vendor rendering	deepar.ai (verified)	0.0.5 (29 Jan 2023)	Android, iOS	Manual deepar.aar, ProGuard rules, permission_handler ^10	Self-serve keys, paid by MAU above 10

Every row in that table is stated in the text above, so nothing lives only in the table. The version column is what each pub.dev listing showed when I read it in October 2026, and every cell is a listing value I copied. Nothing in the table was measured.

What about the vendor SDKs that did not qualify?

Three face SDKs are missing from the table, all for the same reason: you cannot get started on them without talking to someone. They fail differently, so they are worth separating.

FaceUnity has no pub.dev package that I found. Its own effects page, as it read in July 2026, lists Flutter among its platforms, and the documented Flutter route I found runs through Agora: FaceUnity's AR Filter extension for the Agora RTC SDK. You add the native Android .aar files through Gradle and the iOS .framework files through CocoaPods, convert an authpack certificate to Dart, and enable it with enableExtension(provider: "FaceUnity", extension: "Effect", enable: true). The guide asks for Flutter 2.0.0 or higher and Dart 2.15.1 or higher. That route fits apps that already run Agora video calls, and it is a lot of plumbing for a camera filter outside a call. FaceUnity publishes no price list, and access starts with a trial application.

Visage Technologies documents no Flutter or React Native wrapper on its pages as they read in June 2026, with Unity as the only engine it names, so the Flutter side would be platform channels you write yourself. Its pricing page at that time listed a free FaceTrack LITE license for one app up to 10,000 users and technical support billed separately at 1,500 euros per year.

Banuba is the opposite case, and the one worth knowing about if the January 2023 date on deepar_flutter is what rules DeepAR out for you. It does publish a Flutter package, banuba_sdk, under the verified publisher banuba.com, and it has shipped through 2026, with 3.1.4 uploaded on 10 July 2026 and 3.1.7 current when I read the listing in October 2026. Two things the listing does not give you: a license, which shows as unknown rather than MIT, and the platform tags, which were blank on the version page I opened. The access gate is what keeps it out of the screen: the 14-day demo token comes through a website form or a sales manager, not from a developer console, so you cannot get from pub.dev to a running app on your own.

Which Flutter AR package fits which app?

If you are building a face filter app on both platforms and want a vendor renderer, start with deepar_flutter, because it is the only self-serve package here built around switching prepared face effects (switchEffect) on a vendor renderer. Plan to own its Dart layer, since nothing has shipped since January 2023, and check the permission_handler pin against your app first.

If you are building your own overlay or analytics on face geometry, use google_mlkit_face_detection, because it covers Android and iOS from a verified publisher and shipped in August 2026. Add google_mlkit_face_mesh_detection only for an Android-only mesh feature.

If your face feature is iOS only, use arkit_plugin, because it shipped in August 2026 and exposes ARKit face tracking once you turn on the TrueDepth flag.

If you need world AR on both platforms (plane anchors, placed models, cloud anchors), use ar_flutter_plugin_plus over the original ar_flutter_plugin, because the fork shipped in 2026 and the original has not had a release since November 2022.

If you want one Dart API over ARCore and RealityKit with faces included, try augen, the newest upload in the set, and weigh that against an unverified uploader and a Dart 3.9.2 minimum.

If you need face effects in a Flutter web build, none of these seven covers it, so plan a separate web path from day one.

Face tracking in Flutter still means a mobile build and native setup

Across the seven, the Dart API was the easy part. Every face option is mobile only, every one asks for native configuration that flutter pub get does not do, and the upload dates run from October 2026 back to January 2023.

Two findings surprised me: the face mesh package's iOS tag, and the permission_handler pin in DeepAR's own package. Both are visible on the listing pages before anyone writes a line of code, which is the argument for running this screen at all. The device round takes the survivors onto hardware next.