Calling C++ and Go from Dart using FFI

dart:ffi lets Dart call into a shared library (.so or .dylib) directly. No platform channels, no plugin, no Flutter needed.

That is worth having when the code you want already exists in C or C++ and you would rather bind to it than port it, or when a hot loop is faster in a compiled language than in Dart. The cost is that you now have a build step per platform and a pointer or two to look after.

I wired up C++ and Go this way and worked out which other languages can join in. Both are below.

The one rule

Dart can only call functions that expose a C ABI: a plain C-compatible symbol with no name mangling. Every language reaches that differently, but the Dart side never changes: open the library, declare the types, look up the function.

C++

C++ mangles function names, so add becomes something unrecognisable. extern "C" turns that off.

// native/cpp/mylib.cpp
#include <cstdint>

extern "C" {
  int32_t add(int32_t a, int32_t b) {
    return a + b;
  }
}

Build it with CMake:

cmake -S native/cpp -B native/cpp/build -DCMAKE_BUILD_TYPE=Release
cmake --build native/cpp/build

Go

Go exports through CGo. Two details will bite you if you miss them: the file needs package main with an empty func main(), and //export must sit on the line directly above the function, with no blank line between.

// native/go/mylib.go
package main

import "C"

//export multiply
func multiply(a, b int32) int32 { return a * b }

//export fibonacci
func fibonacci(n int32) int64 {
    if n <= 1 { return int64(n) }
    a, b := int64(0), int64(1)
    for i := int32(2); i <= n; i++ { a, b = b, a+b }
    return b
}

func main() {}

Build:

cd native/go && CGO_ENABLED=1 go build -o ../libs/libgolib.so -buildmode=c-shared .

The Dart side

This part is the same no matter which language produced the library. Declare the native signature, declare the Dart signature, then lookupFunction.

// lib/src/go_bindings.dart
import 'dart:ffi';
import 'package:path/path.dart' as p;

typedef _FibonacciNative = Int64 Function(Int32 n);
typedef FibonacciDart = int Function(int n);

class GoLib {
  final DynamicLibrary _lib;
  late final FibonacciDart fibonacci;

  GoLib(String libsDir)
      : _lib = DynamicLibrary.open(p.join(libsDir, 'libgolib.so')) {
    fibonacci = _lib.lookupFunction<_FibonacciNative, FibonacciDart>('fibonacci');
  }
}

Then call it like ordinary Dart:

final go = GoLib(libsDir);
print(go.fibonacci(10)); // 55

Numbers are the easy case. They copy across on their own, and nothing needs cleaning up afterwards.

Strings do not. A Pointer<Utf8> is memory you asked for, so you convert with toNativeUtf8(), pass the pointer, read the reply back with toDartString(), and free what you allocated. Forget the free and you have a leak that no garbage collector will find for you.

Which languages work

Anything that compiles to a shared library with C-compatible symbols.

Works

Does not work

The pattern behind both tables: if the language can produce a .so with plain C symbol names, Dart FFI can call it. If it needs its own runtime to be alive first, it cannot.

Type mappings

C and C++

Go (via CGo)

Rust

Kotlin/Native

Swift

Source

Source code: phanithlim/dart-native

Everything lives under native/, one directory per language, each with its own README and build steps. Clone it, build one of the libraries, and the Dart side will call straight into it.