Rust bindings for writing safe and fast native Node.js modules.



Rust bindings for writing safe and fast native Node.js modules.

Getting started

Once you have the platform dependencies installed, getting started is as
simple as:

  1. ```
  2. $ npm init neon my-project
  3. ```

Then see the Hello World guide for writing your first Hello World in


Neon 0.10 Migration Guide

The latest version of Neon, 0.10, includes a few small breaking changes in order to clean up and improve the usability of our APIs.

Read the new migration guide to learn how to port your
Neon projects to 0.10!

Platform Support

Operating Systems




Support for LTS versions of Node and current are expected. If you're
using a different version of Node and believe it should be supported, let us know.

Bun (experimental)

Bun is an alternate JavaScript runtime that targets Node compatibility. In many cases Neon modules will work in bun; however, at the time of this writing, some Node-API functions are not implemented.


Neon supports Rust stable version 1.18 and higher. We test on the latest stable, beta, and nightly versions of Rust.

A Taste...

  1. ```rust
  2. fn make_an_array(mut cx: FunctionContext) -> JsResult<JsArray> {
  3.     // Create some values:
  4.     let n = cx.number(9000);
  5.     let s = cx.string("hello");
  6.     let b = cx.boolean(true);

  7.     // Create a new array:
  8.     let array: Handle<JsArray> = cx.empty_array();

  9.     // Push the values into the array:
  10.     array.set(&mut cx, 0, n)?;
  11.     array.set(&mut cx, 1, s)?;
  12.     array.set(&mut cx, 2, b)?;

  13.     // Return the array:
  14.     Ok(array)
  15. }

  16. register_module!(mut cx, {
  17.     cx.export_function("makeAnArray", make_an_array)
  18. })
  19. ```

For more examples, see our examples repo.

Get Involved

The Neon community is just getting started and there's tons of fun to be had. Come play! :)

The Neon Community Slack is open to all;
use this invite link to receive an invitation.

Testing Neon

The Neon project is both an NPM workspace and
a Cargo workspace. The full suite of tests may be executed
by installing and testing the NPM workspace.

  1. ```sh
  2. npm install
  3. npm test
  4. ```

Individual JavaScript packages may be tested with an npm workspace command:

  1. ```
  2. npm --workspace=create-neon test
  3. ```

Individual Rust crates may be tested with a cargo workspace command:

  1. ```
  2. cargo test -p neon-build
  3. ```


Licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or
MIT license (LICENSE-MIT or

at your option.