BoltFFI

A high-performance multi-language bindings generator for Rust. Up to 1,000x faster than UniFFI. Up to 450x faster than wasm-bindgen.

Quick links: User Guide | Tutorial | Getting Started

Performance

vs UniFFI (Swift/Kotlin)

vs wasm-bindgen (WASM)

Full benchmark code: benchmarks

Why BoltFFI?

Serialization-based FFI is slow. UniFFI serializes every value to a byte buffer. wasm-bindgen materializes every struct as a JavaScript object. That overhead shows up even when you're making tens or hundreds of FFI calls per second.

BoltFFI uses zero-copy where possible. Primitives pass as raw values. Structs with primitive fields pass as pointers to memory both sides can read directly. WASM uses a wire buffer format that avoids per-field allocation. Only strings and collections go through encoding.

What it does

Mark your Rust types with #[data] and functions with #[export]:

use boltffi::*;

#[data]
pub struct Point {
    pub x: f64,
    pub y: f64,
}

#[export]
pub fn distance(a: Point, b: Point) -> f64 {
    let dx = b.x - a.x;
    let dy = b.y - a.y;
    (dx * dx + dy * dy).sqrt()
}

Run BoltFFI for the targets you need:

boltffi pack apple
# Produces: ./dist/apple/YourCrate.xcframework + Package.swift

boltffi pack android
# Produces: ./dist/android/jniLibs/<abi>/libyour_crate.so + Kotlin bindings

boltffi pack java
# Produces: ./dist/java/native/<host-target>/libyour_crate_jni.* + Java bindings

boltffi pack wasm
# Produces: ./dist/wasm/pkg/*.wasm + TypeScript bindings + npm package

boltffi pack csharp
# Produces: ./dist/csharp/packages/*.nupkg with RID native assets

Android ABI selection is configurable in boltffi.toml:

[targets.android]
architectures = ["arm64"]

Apple slice selection is configurable too:

[targets.apple]
ios_architectures = ["arm64"]
simulator_architectures = ["arm64"]
include_macos = true
macos_architectures = ["arm64"]

Any Apple architecture list can be set to [] to exclude that slice family. For example, set ios_architectures = [] when you want simulator-only Apple packaging from a config overlay. BoltFFI still requires at least one Apple slice overall.

When architectures is omitted, BoltFFI keeps the existing default Android matrix: arm64, armv7, x86_64, and x86. boltffi pack android --no-build now validates that each configured ABI already has a built Rust static library and ignores stale artifacts for unconfigured ABIs.

You can also apply per-invocation overlays without mutating the tracked base config. BoltFFI still requires a base boltffi.toml, then merges the overlay on top for that one command:

boltffi --overlay boltffi.ci.toml pack android
boltffi --overlay boltffi.release.toml pack all --release

This is useful for CI, release builds, or machine-local overrides. boltffi init does not accept --overlay.

Use it from Swift, Kotlin, Java, C#, or TypeScript:

let d = distance(a: Point(x: 0, y: 0), b: Point(x: 3, y: 4)) // 5.0

val d = distance(a = Point(x = 0.0, y = 0.0), b = Point(x = 3.0, y = 4.0)) // 5.0

double d = MyLib.distance(new Point(0.0, 0.0), new Point(3.0, 4.0)); // 5.0

double d = MyLib.Distance(new Point(0.0, 0.0), new Point(3.0, 4.0)); // 5.0

import { distance } from 'your-crate';
const d = distance({ x: 0, y: 0 }, { x: 3, y: 4 }); // 5.0

The generated bindings use each language's idioms. Swift gets async/await. Kotlin gets coroutines. Java gets CompletableFuture and functional interfaces. C# gets Tasks and async enumerables. TypeScript gets Promises. Errors become native exceptions.

Supported languages

Want another language? Open an issue.

Installation

cargo install boltffi_cli

Add to your Cargo.toml:

[dependencies]
boltffi = "0.1"

[lib]
crate-type = ["cdylib", "staticlib"]

Documentation

• Overview
• Getting Started
• Tutorial
• Types
• Async
• Streaming

Alternative tools

Other tools that solve similar problems:

• UniFFI - Mozilla's binding generator, uses serialization-based approach
• Diplomat - Focused on C/C++ interop
• cxx - Safe C++/Rust interop

Contributing

Contributions are warmly welcomed 🙌

• File an issue
• Submit a PR

License

BOLTFFI is released under the MIT license. See LICENSE for more information.