Native interop

Flutter apps run on multiple platforms, but sometimes you need to communicate directly with the host operating system or run code from an existing native library.

To solve this, Flutter provides several interop tools ranging from code generators to direct FFI bindings.

Use the following decision tree to choose your interop solution, or read on to learn about the native interop layers.

Answer the following questions to walk through the decision tree in detail:

Goal A: Platform integration

Communicate with native OS features (Swift, Kotlin, Java, or Objective-C) or expose an API surface. Proceed to Question 2: Do high-complexity constraints apply?.

Goal B: C-ABI wrapping

Wrap an existing native library (C, C++, Rust, or Go). Use FFIgen (or Flutter Rust Bridge for Rust).

Goal C: Pure Dart package

Build a Dart CLI tool without Flutter framework dependencies. Use FFIgen or JNIgen.

If you're building a Flutter plugin, first verify whether Pigeon satisfies your technical constraints.

Do any of the following requirements apply to your feature?

• Your app processes high-frequency raw data (for example, video processing).
• Your integration requires advanced language bridging (for example, cross-language subclasses, delegates, or proxies).
• Your feature requires manual memory management and multithreading over guardrails.
• Your target language is C, C++, Rust, or Go.

Based on whether any of the preceding requirements apply, choose your interop tool:

No (most common) — Use Pigeon

This is the default, recommended path. It provides necessary guardrails, creates easily digestible interface mappings, and is highly efficient for most API surface areas.

Yes — Use FFIgen or JNIgen

You need the flexibility, complexity, and performance of direct interop for larger surface areas.

Depending on how you plan to share your code, choose the option that best suits your use case. To learn about the difference between a packagePackageAt a minimum, a Dart package is a directory containing a `pubspec.yaml` file. Learn more and a pluginPluginA plugin package (generally referred to as _a plugin_), is a special kind of package that makes platform functionallity available to the app. Learn more, refer to the Flutter glossary.

• In-app integration. Write your native interop code directly inside your Flutter app without creating a separate package.
• Plugin. A specialized package that makes native platform functionality (such as a device's camera or sensors) available to your app (flutter create --template=plugin). For more details, refer to Developing plugin packages.
• FFI package. A package that compiles and bundles native C or C++ code (or pre-compiled binaries) using Dart build hooks and dart:ffi. This template also includes an FFIgen configuration to regenerate Dart bindings (flutter create --template=package_ffi). For more details, refer to Developing FFI packages.

For more details on package authoring, refer to Developing packages and plugins.

The following table compares two interop solutions:

• Direct interop: Lower-level direct bindings with higher performance for large data; requires manual memory and threading management.
• Pigeon: Structured, type-safe code generator; recommended default for Flutter plugins.

Dart structures native interop into three distinct layers: low-level bindings, idiomatic Dart APIs, and framework-specific plugins.

For complete architectural details, consult the native interop layers guide.

Layer 1 consists of thin, high-performance, and unopinionated wrappers around native code (for example, dart:ffi, dart:js_interop, FFIgen, and JNIgen). These APIs mirror native signatures closely, but require manual memory and threading management.

Layer 2 consists of idiomatic Dart APIs that wrap the low-level layer to hide platform-specific complexities (for example, Pigeon or the sqlite3 package). These manage concurrency, memory lifetimes, and data conversions automatically.

Layer 3 provides integration with framework-specific APIs (for example, the Flutter Plugin API). This layer exposes Dart APIs to the framework while hiding platform details like Android's Context or iOS's application lifecycle.