Here’s an example showing how to call a Rust function from Deno:

    Compile it to a C dynamic library (libadd.so on Linux):

    1. rustc --crate-type cdylib add.rs

    In C you can write it as:

    1. // add.c
    2. int add(int a, int b) {
    3.   return a + b;
    4. }

    And compile it:

    Calling the library from Deno:

    1. // ffi.ts
    3. // Determine library extension based on
    4. // your OS.
    5. let libSuffix = "";
    6. switch (Deno.build.os) {
    7.   case "windows":
    8.     libSuffix = "dll";
    9.   case "darwin":
    10.     libSuffix = "dylib";
    11.     break;
    12.   case "linux":
    13.     libSuffix = "so";
    14.     break;
    15. }
    17. const libName = `./libadd.${libSuffix}`;
    18. // Open library and define exported symbols
    19. const dylib = Deno.dlopen(libName, {
    20.   "add": { parameters: ["isize", "isize"], result: "isize" },
    21. });
    23. // Call the symbol `add`
    24. const result = dylib.symbols.add(35, 34); // 69
    1. deno run --allow-ffi --unstable ffi.ts

    There are many use cases where users might want to run CPU-bound FFI functions in the background without blocking other tasks on the main thread.

    As of Deno 1.15, symbols can be marked nonblocking in Deno.dlopen. These function calls will run on a dedicated blocking thread and will return a Promise resolving to the desired result.

    Example of executing expensive FFI calls with Deno:

    Calling it from Deno:

    1. // nonblocking_ffi.ts
    2. const library = Deno.dlopen("./sleep.so", {
    3.   sleep: {
    4.     parameters: ["usize"],
    5.     result: "void",
    6.     nonblocking: true,
    7.   },
    8. });
    10. library.symbols.sleep(500).then(() => console.log("After"));
    11. console.log("Before");

    Result:

    1. $ deno run --allow-ffi --unstable unblocking_ffi.ts
    2. Before
    3. After
    • [1] pointer type accepts both Typed Arrays and Deno.UnsafePointer as parameter, while it always returns the latter when used as result type.

    is an external tool to simplify glue code generation of Deno FFI libraries written in Rust.

    It is similar to wasm-bindgen in the Rust WASM ecosystem.

    Here’s an example showing its usage:

    Run deno_bindgen to generate bindings. You can now directly import them into Deno:

    1. // mul.ts
    2. mul({ a: 10, b: 2 }); // 20

    Any issues related to deno_bindgen should be reported at