FFI & C Interop

Rust's Foreign Function Interface lets you reuse decades of battle-tested C libraries and expose fast Rust code to other languages — all through the shared C ABI.

Learn FFI & C Interop in our free Rust course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Rust course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

In this lesson you'll call C from Rust, export Rust functions to C, convert strings across the boundary, and share C-compatible structs — learning where unsafe is required and why.

What You'll Learn in This Lesson

1️⃣ Calling C from Rust

An extern "C" block declares foreign functions using the C calling convention. Their bodies live in a C library you link against. Because Rust can't verify foreign code, every call must sit inside an unsafe block.

The declared signature must match the C function exactly — a mismatch is undefined behaviour, not a compile error, which is part of why this is unsafe .

2️⃣ Calling Rust from C

To make a Rust function callable from C, give it the C ABI with extern "C" and keep its symbol name with #[no_mangle] so the linker can find it under the expected name.

Without #[no_mangle] , Rust mangles the symbol and C could never link to add by name.

3️⃣ Strings and C-Compatible Structs

Rust strings are UTF-8 and not NUL-terminated; C strings are. Convert with CString (owned, to send) and CStr (borrowed, to receive). Whoever allocates a buffer must free it.

For structs, add #[repr(C)] so Rust lays out the fields exactly as C expects. The libc crate supplies the C types, and bindgen can generate these declarations from a header.

Mini-Challenge: Export square to C

Write a C-callable function and the C declaration that would invoke it.

Common Errors (and the fix)

• "call to unsafe function is unsafe" — Wrap the foreign call in an unsafe block.
• C can't find the symbol — Add #[no_mangle] and pub extern "C" to the exported function.
• Garbled struct fields — Add #[repr(C)] so the layout matches C's.
• Crashes passing strings — Use CString / CStr , and free buffers on the side that allocated them.

Pro Tips

• 💡 Wrap unsafe in a safe API: validate inputs once, then keep the rest of your code in safe Rust.
• 💡 Let bindgen do the typing: generate bindings from C headers instead of hand-writing extern blocks.
• 💡 Be explicit about ownership: document and provide a free function for any pointer you hand to C.

📋 Quick Reference — FFI

Goal

Rust Syntax

Declare C fn

extern "C" { fn abs(i: c_int) -> c_int; }

Export to C

#[no_mangle] pub extern "C" fn f()

Foreign call

unsafe { abs(-1) }

Owned C string

CString::new(s)

Borrow C string

CStr::from_ptr(ptr)

C struct layout

#[repr(C)] struct P { .. }

Frequently Asked Questions

🎉 Lesson Complete — and You've Finished the Rust Course!

• ✅ extern "C" bridges Rust and C through the shared C ABI
• ✅ #[no_mangle] exports Rust functions C can link against
• ✅ Foreign calls and raw pointers live in unsafe ; CString / CStr bridge strings
• ✅ #[repr(C)] , libc , and bindgen make struct and library interop practical
• 🎓 Congratulations — you've completed the entire Rust course! From ownership and borrowing through generics, traits, async, web servers, databases, and now FFI, you've covered the full toolkit for writing fast, safe, production-grade Rust. Go build something great.

Practice quiz

Continue this course

• Previous: Database Access with sqlx
• Next: Serialization with Serde