C interop using dart:ffi

Dart mobile, command-line, and server apps running on the Dart Native platform can use the dart:ffi library to call native C APIs, and to read, write, allocate, and deallocate native memory. FFI stands for foreign function interface. Other terms for similar functionality include native interface and language bindings.

API documentation is available in the dart:ffi API reference.

Examples

The following examples show how to use the dart:ffi library:

Walkthrough of hello_world

The hello_world example has the minimum necessary code for calling a C library.

Files

The hello_world example has the following files:

Building the C library creates several files, including a dynamic library file named libhello.dylib (macOS), libhello.dll (Windows), or libhello.so (Linux).

Building and running

Here’s an example of building the dynamic library and executing the Dart app:

$ cd hello_library
$ cmake .
...
$ make
...
$ cd ..
$ dart pub get
$ dart run hello.dart
Hello World

Using dart:ffi

The hello.dart file illustrates the steps for using dart:ffi to call a C function:

1. Import dart:ffi.
2. Import the path library that you’ll use to store the path of dynamic library.
3. Create a typedef with the FFI type signature of the C function.
4. Create a typedef for the variable that you’ll use when calling the C function.
5. Create a variable to store the path of the dynamic library.
6. Open the dynamic library that contains the C function.
7. Get a reference to the C function, and put it into a variable.
8. Call the C function.

Here’s the code for each step.

1. Import dart:ffi.

   import 'dart:ffi' as ffi;
   

2. Import the path library that you’ll use to store the path of dynamic library.

   import 'dart:io' show Platform, Directory;
   import 'package:path/path.dart' as path;
   

3. Create a typedef with the FFI type signature of the C function.
   See Interfacing with native types for commonly used types defined by dart:ffi library.

   typedef hello_world_func = ffi.Void Function();
   

4. Create a typedef for the variable that you’ll use when calling the C function.

   typedef HelloWorld = void Function();
   

5. Create a variable to store the path of the dynamic library.

   var libraryPath = path.join(Directory.current.path, 'hello_library',
    'libhello.so');
   if (Platform.isMacOS) { 
     libraryPath = path.join(Directory.current.path, 'hello_library', 
      'libhello.dylib');
   } else if (Platform.isWindows) { 
     libraryPath = path.join(Directory.current.path, 'hello_library', 
      'Debug', 'hello.dll');
   } 
   

6. Open the dynamic library that contains the C function.

     final dylib = ffi.DynamicLibrary.open(libraryPath);
   

7. Get a reference to the C function, and put it into a variable. This code uses the typedefs defined in steps 2 and 3, along with the dynamic library variable from step 4.

     final HelloWorld hello = dylib
      .lookup<ffi.NativeFunction<hello_world_func>>('hello_world')
      .asFunction();
   

8. Call the C function.

     hello();
   

Once you understand the hello_world example, you should be ready to look at the other dart:ffi examples.

Bundling and loading C libraries

How you bundle (or package or distribute) a C library with your package or app and then load that library depends on your platform and the type of library. For details, see the following:

• Flutter dart:ffi pages: Android, iOS, and macOS
• dart:ffi examples

Interfacing with native types

The dart:ffi library provides multiple types that implement NativeType and represent native types in C.

Some native types are only used as markers in type signatures while others (or their subtypes) can be instantiated.

Instantiable native types

The following native types can be used as markers in type signatures and they (or their subtypes) can be instantiated in Dart code:

Purely marker native types

The following are platform-agnostic native types that are used only as markers in type signatures, and can’t be instantiated in Dart code:

There are also many ABI specific marker native types that extend AbiSpecificInteger. Refer to their linked API documentation for more information and a guideline on what types they map to on specific platforms:

Generating FFI bindings with package:ffigen

For large API surfaces it can be time-consuming to write the Dart bindings that integrate with the C code. To reduce this burden, you can use the package:ffigen binding generator to automatically create FFI wrappers from C header files.