FFI call c code

[MateusDornelles]

is it possible to call c code ?

[proggeramlug]

Yes — Perry has a first-class FFI mechanism for calling native code (Rust, Swift on Apple, JNI on Android, and via Rust → C anything that compiles to a static library). It's called native extensions and the full docs live at https://docs.perryts.com/plugins/native-extensions.html.

For pure C, the cleanest path is to wrap your C in a tiny Rust staticlib (Cargo's cc crate compiles the .c file for you in build.rs), declare the C functions on the TypeScript side with declare function, and let Perry's --bundle-extensions flag link everything in. Here's a minimal, complete example.

1. Project layout

my-app/
├── package.json
├── src/index.ts
└── extensions/
    └── perry-mathc/
        ├── package.json
        └── crate/
            ├── Cargo.toml
            ├── build.rs
            ├── src/lib.rs       # Rust shim — declares the C functions
            └── c/mathc.c        # Your C code

2. The C code — extensions/perry-mathc/c/mathc.c

#include <stdint.h>

int64_t mathc_add(int64_t a, int64_t b) {
    return a + b;
}

3. Cargo + build.rs that compile the C — extensions/perry-mathc/crate/Cargo.toml

[package]
name = "perry_mathc"
version = "0.1.0"
edition = "2021"

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

[build-dependencies]
cc = "1.0"

// build.rs
fn main() {
    cc::Build::new()
        .file("../c/mathc.c")
        .compile("mathc");
}

4. Rust shim that re-exports the C symbol with Perry's NaN-boxing — crate/src/lib.rs

Perry's runtime values cross the FFI boundary as NaN-boxed f64. For numeric in/out you just convert.

extern "C" {
    fn mathc_add(a: i64, b: i64) -> i64;
}

#[no_mangle]
pub extern "C" fn perry_mathc_add(a: f64, b: f64) -> f64 {
    let r = unsafe { mathc_add(a as i64, b as i64) };
    r as f64
}

5. Manifest — extensions/perry-mathc/package.json

{
  "name": "perry-mathc",
  "version": "0.1.0",
  "main": "src/index.ts",
  "perry": {
    "nativeLibrary": {
      "functions": [
        { "name": "perry_mathc_add", "params": ["f64", "f64"], "returns": "f64" }
      ],
      "targets": {
        "macos":   { "crate": "crate", "lib": "libperry_mathc.a" },
        "linux":   { "crate": "crate", "lib": "libperry_mathc.a" },
        "ios":     { "crate": "crate", "lib": "libperry_mathc.a" },
        "android": { "crate": "crate", "lib": "libperry_mathc.a" }
      }
    }
  }
}

6. TypeScript entry — extensions/perry-mathc/src/index.ts

declare function perry_mathc_add(a: number, b: number): number;

export function add(a: number, b: number): number {
  return perry_mathc_add(a, b);
}

7. App code — src/index.ts

import { add } from "perry-mathc";

console.log(add(40, 2));   // 42

8. Build

perry src/index.ts -o app --bundle-extensions ./extensions
./app

Perry sees the perry.nativeLibrary manifest, runs cargo build --release in crate/ (which triggers build.rs, which calls cc to compile your .c), links the resulting libperry_mathc.a into your binary, and replaces add(...) at the TS call site with a direct native call. No runtime, no dlopen — it's all one statically-linked executable.

Variants

• Existing C library on the system (e.g. libcurl): skip the Rust shim's cc::Build and just add "libs": ["curl"] to the target config — Perry passes that to the linker as -lcurl. You still want a thin Rust wrapper to convert NaN-boxed args, but you don't compile any C yourself.
• C++: same recipe, just feed .cpp to cc::Build::new().cpp(true) (or use the cmake crate for bigger projects).
• Strings / objects / async: cross the boundary as NaN-boxed values via the runtime helpers js_get_string_pointer_unified, js_string_from_bytes, js_promise_new / js_promise_resolve — listed in the docs page linked above.

So the answer to "is it possible to call C code?" is yes, and the mechanism is the same one Perry's built-in stdlib (mysql2, sharp, sqlite, etc.) uses internally — it's just exposed for you to add your own libraries.

[MateusDornelles]

Hey, thanks for your answer