neon-bindings/neon
Neon
Neon is a framework for writing high-performance native Node.js modules using the Rust programming language. It serves as a foreign function interface bridge and a toolchain for bootstrapping, compiling, and managing Rust-based extensions.
The project provides a cross-language memory manager that handles buffers and object borrowing to ensure safe memory access between Rust and JavaScript. It enables the mapping of data types and function calls across the language boundary, allowing Rust functions to be exported to the script environment and JavaScript functions to be called from Rust.
The framework covers asynchronous native processing by wrapping Rust futures into JavaScript promises and managing communication between background threads and the main execution thread. It also supports multi-platform binary compilation to ensure native modules are compatible across different operating systems.
Features
- Foreign Function Interfaces - Serves as a high-performance foreign function interface bridge between the JavaScript runtime and Rust.
- Rust Implementations - Enables the creation of high-performance Node.js native extensions specifically using the Rust programming language.
- Native Module Bridges - Acts as a native module bridge enabling seamless communication between high-level JavaScript and low-level Rust.
- Native Module Development - Provides the framework and toolchain to develop high-performance native extensions for Node.js using Rust.
- Shared Memory Buffers - Provides shared memory buffers to allow zero-copy data exchange between Rust and JavaScript.
- Script-to-Native Type Mappings - Maps JavaScript data types to Rust primitives for precise data handling across the language boundary.
- Language Type Mappers - Provides systems to map JavaScript data types to Rust primitives for precise cross-language data handling.
- Native Binary Toolchains - Ships a toolchain to compile Rust source code into platform-specific native binaries for execution.
- Cross-Language Memory Managers - Implements a cross-language memory manager to ensure safe object borrowing and memory access between Rust and JS.
- Asynchronous Promise Interfaces - Implements a promise-based API to bridge native Rust futures with the JavaScript event loop.
- Node-API Integrations - Utilizes the standardized N-API C interface to ensure binary compatibility across different Node.js versions.
- Asynchronous Processing - Enables non-blocking background processing in Rust that integrates directly with JavaScript promises.
- Node.js Native Addons - Provides a comprehensive framework for developing native Node.js addons that offer low-level system access.
- Function Exports - Exports Rust functions to the JavaScript environment so they can be executed as native modules.
- Native Module Build Utilities - Provides a CLI tool to bootstrap project boilerplate and automate the build process for native modules.
- Cross-Platform Build Targets - Supports building native modules for multiple operating systems and runtime versions.
- Native Module Toolchains - Ships a toolchain for bootstrapping, compiling, and managing the build process of Rust-based Node.js extensions.
- Script Invocation Interfaces - Enables Rust code to invoke JavaScript functions, including methods on objects and custom closures.
- Cross-Platform Binary Generation - Supports generating platform-specific executable binaries for various operating systems and CPU architectures.
- Thread-Safe Dispatchers - Provides thread-safe dispatching to schedule callbacks on the main execution thread from background Rust threads.
- Asynchronous Task Execution - Manages the execution of long-running native operations in the background without blocking the main thread.
- Cross-Language Panic Mapping - Catches Rust runtime panics and converts them into JavaScript exceptions to prevent the process from crashing.
- Panic Recovery - Provides panic recovery to convert native crashes into graceful JavaScript exceptions.
- Inter-Thread Communication - Facilitates inter-thread communication by scheduling work on the main execution thread from background Rust threads.
- Cross-Platform Integration - Rust bindings for safe native Node.js modules.
- Foreign Function Interface - Bindings for writing native Node.js modules in Rust.
