C and Rust Interoperability: Bridging the Language Gap

Ever had that moment where you’re knee-deep in Rust’s fearless concurrency and memory safety, but then—bam!—you hit a wall because you need to call some legacy C library or squeeze out every last drop of performance from hand-tuned C code? Yeah, me too. Mixing C and Rust can feel like trying to get two rock bands to jam together without stepping on each other’s solos. But when done right, it’s a symphony of power and safety.

Let’s tear down the walls between these two languages and build a bridge that lets you wield the best of both worlds. We’ll get our hands dirty with the nitty-gritty: from extern blocks and FFI safety to memory layout and calling conventions. By the end, you’ll be writing hybrid apps that are blazingly fast and safe.

Why Even Bother with C and Rust Together?

Rust is a systems language with killer safety guarantees, but C is the lingua franca of legacy code, OS kernels, and embedded systems. Sometimes you:

Need to reuse battle-tested C libraries.
Want to incrementally migrate a C codebase to Rust.
Need to squeeze max performance by calling hand-optimized assembly or intrinsics in C.
Are writing bindings for a hardware driver or OS API.

Interoperability is the secret sauce that lets you leverage Rust’s modern features without rewriting everything from scratch.

The FFI Basics: Talking Across the Language Divide

Rust calls foreign functions using the Foreign Function Interface (FFI). It’s basically a contract that tells Rust how to call C functions and handle data safely.

Step 1: Declare Your `extern` Block

Rust’s extern keyword is your gateway to C-land. It tells the Rust compiler, “Hey, this function lives somewhere else, probably in a C library, so don’t mess with its calling convention.”

extern "C" {
    fn puts(s: *const libc::c_char) -> libc::c_int;
}

"C" specifies the C calling convention (important!).
Function signatures must match exactly — Rust is not forgiving here.

Step 2: Use Raw Pointers and `unsafe`

Since Rust can’t guarantee safety across language boundaries, calling foreign functions is unsafe. You’re responsible for all those footguns (dangling pointers, null checks, etc.).

use std::ffi::CString;

fn main() {
    let msg = CString::new("Hello from Rust calling C!").unwrap();
    unsafe {
        puts(msg.as_ptr());
    }
}

CString ensures your string is null-terminated — a C must-have.

Data Layout: Making Your Structs Speak the Same Language

Rust and C both have structs, but their layouts can differ due to padding and alignment rules. To guarantee compatibility, use #[repr(C)] on Rust structs:

#[repr(C)]
struct Point {
    x: f64,
    y: f64,
}

This tells Rust to layout Point just like a C compiler would.

Passing Structs Back and Forth

// C side
typedef struct {
    double x, y;
} Point;

void print_point(Point p) {
    printf("Point(x=%f, y=%f)\n", p.x, p.y);
}

#[repr(C)]
struct Point {
    x: f64,
    y: f64,
}

extern "C" {
    fn print_point(p: Point);
}

fn main() {
    let p = Point { x: 3.14, y: 2.71 };
    unsafe {
        print_point(p);
    }
}

Handling Ownership and Lifetimes Across FFI

Rust’s ownership model doesn’t magically apply to C. You must manually manage memory boundaries.

If C allocates memory, Rust must free it properly (and vice versa).
Use raw pointers and explicit deallocation functions.
For strings, convert between Rust’s String/&str and C’s null-terminated strings (CString and CStr).

Example: Freeing C-allocated strings in Rust

// C code
char* get_message() {
    char* msg = malloc(20);
    strcpy(msg, "Hello from C!");
    return msg;
}

void free_message(char* msg) {
    free(msg);
}

extern "C" {
    fn get_message() -> *mut libc::c_char;
    fn free_message(msg: *mut libc::c_char);
}

fn main() {
    unsafe {
        let msg_ptr = get_message();
        if !msg_ptr.is_null() {
            let msg = std::ffi::CStr::from_ptr(msg_ptr);
            println!("Message from C: {}", msg.to_str().unwrap());
            free_message(msg_ptr);
        }
    }
}

When Things Get Tricky: Callbacks and Function Pointers

Passing Rust functions as callbacks to C is a classic yak-shave. C expects raw function pointers with no captures, but Rust closures often capture environment variables.

Solution: Use extern "C" functions and pass a user data pointer.

// C code
typedef void (*callback_t)(int, void*);

void register_callback(callback_t cb, void* user_data);

void trigger_callback();

extern "C" fn my_callback(value: i32, user_data: *mut std::ffi::c_void) {
    let closure = unsafe { &mut *(user_data as *mut Box<dyn FnMut(i32)>) };
    closure(value);
}

fn main() {
    let mut closure = Box::new(|val| println!("Callback called with {}", val));
    unsafe {
        register_callback(Some(my_callback), &mut closure as *mut _ as *mut _);
        trigger_callback();
    }
}

This pattern lets you store Rust state safely and call it from C.

Pro Tips & Pitfalls

Always match calling conventions. "C" is the default for C interop. Mismatches cause stack corruption.
Beware of #[repr(Rust)] structs. Default Rust struct layouts aren’t C-compatible.
Null pointers are real. Rust’s references are non-null, but raw pointers can be null — check before dereferencing.
Use bindgen for big C APIs. It auto-generates Rust bindings from C headers, saving you from manual declarations.
Test your FFI boundary thoroughly. Memory bugs here are subtle and painful.

TL;DR

Use extern "C" blocks and unsafe to call C from Rust.
Match data layouts with #[repr(C)].
Manage memory manually across the FFI boundary.
Use CString and CStr for safe string interop.
Pass callbacks with function pointers and user data.
Always respect calling conventions and nullability.
Automate bindings with bindgen when possible.

The Mic Drop

C and Rust don’t have to be frenemies — they can be co-pilots on your systems programming journey. When you master their interoperability, you unlock a hybrid beast: the raw power of C with the safety and expressiveness of Rust. So, what legacy C monster will you tame with Rust next? Drop your war stories and tips below! 🚀⚙️🔥