FFI (Foreign Function Interface) for native code in Deno - Step-by-Step Execution

Concept Flow - FFI (Foreign Function Interface) for native code

Start Deno Script

↓

Load Native Library

↓

Define FFI Interface

↓

Call Native Function

↓

Receive Result

↓

Use Result in JS

↓

End Script

This flow shows how Deno loads a native library, defines the interface to call native functions, executes them, and uses the results in JavaScript.

Execution Sample

Deno

const dylib = Deno.dlopen("./libmath.so", {
  add: { parameters: ["i32", "i32"], result: "i32" },
});

const result = dylib.symbols.add(5, 3);
console.log(result);
dylib.close();

This code loads a native library with an 'add' function, calls it with 5 and 3, prints the result, then closes the library.

Execution Table

Step	Action	Evaluation	Result
1	Load native library './libmath.so'	Deno.dlopen called	Library loaded with 'add' symbol
2	Define FFI interface for 'add'	Parameters: i32, i32; Result: i32	Interface ready
3	Call 'add' with arguments 5 and 3	add(5, 3)	Returns 8
4	Print result	console.log(8)	Output: 8
5	Close library	dylib.close()	Library unloaded

💡 Script ends after closing the native library

Variable Tracker

Variable	Start	After Step 3	Final
dylib	undefined	Object with 'add' symbol	Closed (unloaded)
result	undefined	8	8

Key Moments - 3 Insights

Why do we need to define the parameter and result types in the FFI interface?

Because Deno needs to know how to convert JavaScript values to native types and back. See execution_table step 2 where the interface is defined with types.

What happens if the native function returns a different type than declared?

The result may be incorrect or cause errors. Deno relies on the declared types to handle data correctly, as shown in step 3 where the call returns 8 as an i32.

Why do we call dylib.close() at the end?

To free resources and unload the native library properly, preventing memory leaks. See step 5 in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 3?

A 8

B 5

C 3

D undefined

💡 Hint

Check the 'Result' column in execution_table row for step 3

At which step is the native library unloaded?

A Step 2

B Step 3

C Step 5

D Step 4

💡 Hint

Look for 'Library unloaded' in the 'Result' column of execution_table

If we change the parameter types in the interface to 'f64' instead of 'i32', what would happen?

A The native function would receive integers anyway

B The native function would receive floating point numbers

C Deno would throw a syntax error

D The library would fail to load

💡 Hint

Refer to execution_table step 2 about parameter type definitions

Concept Snapshot

FFI in Deno lets JavaScript call native code.
Load native library with Deno.dlopen(path, symbols).
Define function signatures with parameter and result types.
Call native functions via dylib.symbols.funcName(args).
Close library with dylib.close() to free resources.

Full Transcript

This lesson shows how to use Deno's Foreign Function Interface (FFI) to call native code from JavaScript. First, the native library is loaded using Deno.dlopen with the path and function signatures. The signatures specify parameter and return types so Deno can convert data correctly. Then, the native function is called through the symbols object. The result is received and can be used in JavaScript. Finally, the library is closed to release resources. This process allows JavaScript to use fast native code safely and efficiently.

Practice

1. What is the main purpose of using Deno.dlopen in Deno's FFI?

easy

A. To load a native shared library and access its functions

B. To compile TypeScript code into JavaScript

C. To start a web server in Deno

D. To read files from the filesystem

Solution

1. Step 1: Understand the role of Deno.dlopen

   Deno.dlopen is used to load native shared libraries (like .dll, .so, .dylib) so Deno can call native functions.

2. Step 2: Compare with other options

   Options B, C, and D relate to other Deno features but not FFI or native code loading.

3. Final Answer:

   To load a native shared library and access its functions -> Option A

4. Quick Check:

   Deno.dlopen loads native libraries = A [OK]

Hint: Remember: dlopen means 'dynamic library open' [OK]

Common Mistakes:

• Confusing dlopen with file reading functions
• Thinking dlopen compiles code
• Mixing up server start with FFI loading

2. Which of the following is the correct way to define a function signature for a native function returning an integer in Deno.dlopen?

easy

A. { myFunc: { parameters: ["i32"], result: "void" } }

B. { myFunc: { parameters: ["i32"], result: "i32" } }

C. { myFunc: { parameters: ["void"], result: "i32" } }

D. { myFunc: { parameters: [], result: "string" } }

Solution

1. Step 1: Understand function signature format

   Function signatures in Deno.dlopen require specifying parameter types and the return type. For a function taking an integer and returning an integer, both parameters and result should be "i32".

2. Step 2: Analyze each option

   { myFunc: { parameters: ["i32"], result: "void" } } returns void, not integer. { myFunc: { parameters: ["void"], result: "i32" } } has parameters as void which is invalid. { myFunc: { parameters: [], result: "string" } } returns string but parameters are empty. Only { myFunc: { parameters: ["i32"], result: "i32" } } correctly matches integer parameter and integer return.

3. Final Answer:

   { myFunc: { parameters: ["i32"], result: "i32" } } -> Option B

4. Quick Check:

   Integer parameter and return = C [OK]

Hint: Match parameter and result types exactly as strings [OK]

Common Mistakes:

• Using 'void' as a parameter type incorrectly
• Mixing return and parameter types
• Using unsupported types like 'string' without proper handling

3. Given the following code snippet, what will be the output?

const lib = Deno.dlopen("./libmath.so", {
  add: { parameters: ["i32", "i32"], result: "i32" }
});

const result = lib.symbols.add(10, 5);
console.log(result);
lib.close();

medium

A. undefined

B. 105

C. 15

D. Runtime error

Solution

1. Step 1: Understand the function signature and call

   The native function 'add' takes two 32-bit integers and returns a 32-bit integer. Calling add(10, 5) should return 15.

2. Step 2: Analyze the output

   The console.log prints the returned value, which is 15. No errors occur because the signature matches and the library is closed properly.

3. Final Answer:

   15 -> Option C

4. Quick Check:

   Adding 10 + 5 = 15 [OK]

Hint: Check parameter types and expected return for output [OK]

Common Mistakes:

• Concatenating numbers as strings (getting 105)
• Forgetting to close the library
• Assuming undefined return without checking signature

4. Identify the error in this Deno FFI code snippet:

const lib = Deno.dlopen("./libcalc.so", {
  multiply: { parameters: ["i32", "i32"], result: "i64" }
});

const output = lib.symbols.multiply(3, 4);
console.log(output);
lib.close();

medium

A. The result type should be "i32" instead of "i64"

B. The parameters array should be empty

C. The library path is incorrect

D. The function call syntax is invalid

Solution

1. Step 1: Check function signature consistency

   The function 'multiply' takes two 32-bit integers and likely returns a 32-bit integer. Using "i64" as result type can cause mismatch errors if the native function returns 32-bit.

2. Step 2: Validate other parts

   Parameters are correctly specified as two "i32". The library path and function call syntax are valid assuming the file exists and function is exported.

3. Final Answer:

   The result type should be "i32" instead of "i64" -> Option A

4. Quick Check:

   Result type must match native function = D [OK]

Hint: Match return type exactly with native function signature [OK]

Common Mistakes:

• Changing parameter types incorrectly
• Assuming library path error without checking
• Misusing function call syntax

5. You want to call a native function that returns a pointer to a UTF-8 string. Which approach correctly handles this in Deno FFI?

hard

A. Define the function with result type "string" and use it directly

B. Define the function with result type "i32" and convert to string

C. Define the function with result type "void" and cast the result to string

D. Define the function with result type "pointer", then use Deno.UnsafePointerView to read the string

Solution

1. Step 1: Understand pointer return handling

   Native functions returning strings usually return pointers. Deno FFI requires defining the result as "pointer" to get the address.

2. Step 2: Use Deno.UnsafePointerView to read UTF-8

   After getting the pointer, Deno.UnsafePointerView can read the memory as a UTF-8 string safely.

3. Final Answer:

   Define the function with result type "pointer", then use Deno.UnsafePointerView to read the string -> Option D

4. Quick Check:

   Pointer + UnsafePointerView for strings = B [OK]

Hint: Use pointer type and UnsafePointerView for native strings [OK]

Common Mistakes:

• Using 'string' as result type directly
• Casting void or integer to string incorrectly
• Ignoring memory safety when reading pointers