/dart-use-ffigen

name: dart-use-ffigen
description: Guide agents to use `package:ffigen` to automatically generate FFI bindings instead of writing them manually. Use this skill when a task involves writing new FFI bindings, extending C/Objective-C/Swift integrations, or replacing hand-crafted `dart:ffi` setups.
metadata:
  model: models/gemini-3.1-pro-preview
  last_modified: Thu, 28 May 2026 07:21:07 GMT

Generating FFI Bindings using package:ffigen

Contents

• [Introduction](#introduction)
• [Constraints](#constraints)
• [FFIgen Overview](#ffigen-overview)
• [Step-by-Step Workflow](#step-by-step-workflow)
• [Concrete Example: Binding a C Library](#concrete-example-binding-a-c-library)
• [Verification Checklist](#verification-checklist)

Introduction

Automate and standardize the generation of FFI bindings using `package:ffigen` (`FfiGenerator`). Writing FFI bindings by hand is error-prone, brittle, and highly discouraged.

Constraints

• **No Hand-Written FFI Bindings**: If native headers (`.h` files) exist or are generated by a build step, never write manual `DynamicLibrary.lookup`, `@Native` external functions, or raw struct classes. Always use `FfiGenerator` to generate them.
• **Generator Location**: The generator script should be located at `tool/ffigen.dart` within the target package root.
• **Header Location**: If the native header files are third-party, they should be located in `third_party/` within the target package (otherwise placing them in a `src/` directory at the package root is also acceptable). If the headers are not in one of these standard locations, notify the user that it would be cleaner to move the header files to the standard location (e.g., `third_party/`).
• **Targeted Inclusion Filters**: Avoid importing an entire native library unless specifically needed. Always apply precise inclusion lists using positive matches to minimize the size and cognitive load of the generated code (e.g., using `Functions.includeSet` or filtering matches in `include` closures).
• **Output Setup**: If the generated FFI bindings interface with a third-party library (or reference third-party headers), the generated files must always be placed under `lib/src/third_party/`. The primary generated FFI bindings file must strictly use the `.g.dart` extension (e.g. `sqlite3.g.dart`).
• **Preamble & License Headers**: Always supply a premium `preamble` in the `Output` class to specify the license. This must match the native third-party library's license, explicitly include the copyright header of the target native header file, and contain an automatic generation warning (e.g. `// Generated by package:ffigen. Do not edit manually.`).
• **No Unnecessary Commits of Stale Bindings**: Ensure you run the generator script and check if the generated files have changed *before* finishing your task. Always verify the package by running `dart analyze`.
• **Record Usage and Tree Shaking**: If the package is integrated into standard runtime execution or compiles native assets via native hooks:
• Enable recorded usage on all functions by setting `recordUse: (_) => true` under `Functions`.
• Specify the `recordUseMapping` target in `Output` (which must strictly be a `.g.dart` file under `lib/src/third_party/`, e.g. `lib/src/third_party/sqlite3.record_use_mapping.g.dart`) to register bindings for symbol tree shaking.

FFIgen Overview

To construct the programmatic generator, use the core configuration objects imported from `package:ffigen/ffigen.dart`:

1. `FfiGenerator`

The parent class that orchestrates the configuration, parsing, and code generation.

FfiGenerator({
  Headers headers = const Headers(),
  Enums enums = Enums.excludeAll,
  Functions functions = Functions.excludeAll,
  Globals globals = Globals.excludeAll,
  Integers integers = const Integers(),
  Macros macros = Macros.excludeAll,
  Structs structs = Structs.excludeAll,
  Typedefs typedefs = Typedefs.excludeAll,
  Unions unions = Unions.excludeAll,
  UnnamedEnums unnamedEnums = UnnamedEnums.excludeAll,
  ObjectiveC? objectiveC,
  required Output output,
}).generate();

2. `Headers`

Configures Clang header parsing targets and compiler flags.

• `entryPoints`: A list of target header `Uri` inputs.
• `include`: A filter function `bool Function(Uri header)` that handles transitive header imports.
• `compilerOptions`: Custom preprocessor/include compiler flags to pass directly to libclang.
• `ignoreSourceErrors`: Set to `true` to silence errors occurring inside third-party headers during parsing.

3. `Functions`

Specifies which native C/C++ functions to expose in Dart.

• `include`: A matcher function (e.g. `(decl) => {'my_func'}.contains(decl.originalName)` or `Functions.includeSet({'my_func'})`).
• `isLeaf`: Declares functions as leaf functions (`(decl) => true`) if they do not call back into Dart or block thread execution.
• `recordUse`: Enables metadata generation for native asset tree shaking (essential in `dart-lang/native`). Set to `(_) => true`.

4. `Output`

Configures target generated files.

• `dartFile`: Target `Uri` where the primary FFI bindings will be written.
• `recordUseMapping`: Target `Uri` for recorded usage metadata maps (crucial for linking-time tree shaking).
• `preamble`: Text inserted at the top of the generated file (licensing, annotations).
• `format`: Set to `true` to run the Dart formatter automatically.

Step-by-Step Workflow

Step 1: Check/Add Dependencies

Open the package's `pubspec.yaml` and verify the `dev_dependencies` contains `ffigen`. Use the Dart MCP server or look up the latest version on [pub.dev](https://pub.dev/packages/ffigen) (e.g., `^20.1.1`).

You can add it automatically using the CLI:

dart pub add dev:ffigen

Step 2: Formulate Paths Dynamically

Create a programmatic generator script under the package's `tool/` directory (e.g., `tool/ffigen.dart`). Resolve paths relative to `Platform.script` to mak