Rust and N-API: High-Performance Node.js Native Modules

If you've been around the Node.js ecosystem for a while, you know that writing native C++ modules is a nightmare. Before Node.js 8, we were stuck with NAN (Native Abstractions for Node). Every time a new version of Node or V8 was released, your native module would break, and you'd spend days fixing it.

In 2018, we have something better: N-API (Node-API). It's an ABI-stable interface. You build your native module once, and it works across Node versions without recompiling. And instead of C++, we're using Rust.

Why Rust for Native Modules?

Rust gives us C-level performance with memory safety. No more segfaults or "undefined behavior" that crashes your entire Node process. We use the neon crate or the lower-level napi-rs to bridge the gap.

A Practical Example: Heavy Math

Let's say we need to calculate Fibonacci sequences (a classic example of Node's single-threaded weakness). Here's how we'd implement it in Rust:

// lib.rs
use neon::prelude::*;

fn fibonacci(n: i32) -> i32 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}

fn hello(mut cx: FunctionContext) -> JsResult<JsNumber> {
    let n = cx.argument::<JsNumber>(0)?.value(&mut cx) as i32;
    let result = fibonacci(n);
    Ok(cx.number(result))
}

#[neon::main]
fn main(mut cx: ModuleContext) -> NeonResult<()> {
    cx.export_function("fibonacci", hello)?;
    Ok(())
}

The Toolchain: Neon

We use neon-cli to scaffold and build our project:

# Install neon globally
npm install -g neon-cli

# Create a new project
neon new my-rust-module

# Build the module
neon build --release

In your Node.js file, it feels like regular JavaScript:

const myModule = require('./my-rust-module');

console.time('fib');
console.log(myModule.fibonacci(40)); // Fast and safe!
console.timeEnd('fib');

N-API and ABI Stability

N-API ensures that the binary we just built will still work when Node 11 or Node 12 comes out. This is a massive improvement for CI/CD and production reliability.

For anyone who needs to do heavy image processing, cryptographic operations, or complex data transformation, 2018 is the year to stop fighting with C++ and start leveraging Rust in Node.js.