wasm-bindgen/wasm-bindgen
Wasm Bindgen
wasm-bindgen is a glue code generator and interoperability tool that facilitates high-level communication and data exchange between compiled Rust modules and JavaScript environments. It functions as a memory bridge and type definition generator, allowing the exchange of complex data types and the calling of functions across execution boundaries.
The project distinguishes itself by automating the conversion of data types and function signatures using attribute-based bindings. It generates the necessary JavaScript and WebAssembly wrappers to manage linear memory mapping and creates automatic TypeScript type bindings to provide static checking and autocomplete.
The framework covers several capability areas, including host interaction for invoking web APIs and DOM manipulation, as well as asynchronous coordination between promises and futures. It also provides mechanisms for multi-threaded execution coordination across web workers and the translation of exceptions between the guest module and the host.
Tooling is included for executing test suites within headless browser environments.
Features
- JavaScript Interop - Exposes internal Rust functions as callable modules for execution within JavaScript environments.
- WebAssembly Glue Code Generators - Automatically generates the necessary JavaScript and WebAssembly glue code to facilitate high-level communication between Rust and the browser.
- Complex Data Type Exchange - Enables the exchange of complex objects, strings, and classes beyond simple numeric types.
- Type-Safe Binding Generators - Generates static TypeScript type definitions to ensure data consistency and provide autocomplete when calling modules from JavaScript.
- Linear Memory Managers - Reads and writes data to a shared contiguous buffer to exchange strings and objects between the host and module.
- Foreign Function Bindings - Invokes native functions and web APIs from within Rust source code by defining external bindings.
- Host Function Exposure - Allows compiled modules to call external JavaScript logic and system APIs for tasks such as DOM manipulation.
- JavaScript Interoperability - Facilitates high-level communication and data exchange between compiled Rust modules and the host JavaScript environment.
- Module Interface Exports - Exposes functions and classes from a compiled WebAssembly module so they can be called by the host environment.
- Language Interoperability Automation - Automates the conversion of data types and function calls between Rust and JavaScript.
- WebAssembly Bridges - Provides a high-level bridge for exporting functions and exchanging complex data types between WebAssembly and JavaScript.
- Cross-Language Type Export - Generates JavaScript classes and type definitions from internal Rust structures to maintain consistency.
- Type Conversion and Casting - Transforms data between JavaScript values and Rust types, including primitives, strings, and vectors.
- Type Definition Generators - Automatically synthesizes static TypeScript type definitions from compiled Rust structures for use in external environments.
- Host Environment Integration - Embeds functions and objects from the host environment into Rust source code for use within compiled modules.
- Shared Memory Buffers - Provides shared memory buffers and atomic operations to coordinate execution across multiple web worker threads.
- Async Runtime Bridges - Translates asynchronous handles between the host event loop and the guest runtime to allow cross-environment awaiting.
- Asynchronous Promise Interfaces - Provides mechanisms to bridge JavaScript promises and Rust futures for cross-environment asynchronous operations.
- Cross-Language Prototype Mapping - Creates prototype chains between exported structures to support method dispatch and instance checks in JavaScript.
- ES Module Integrations - Provides a compatibility layer to import and use compiled WebAssembly modules as standard ECMAScript modules.
- JavaScript Multi-Threading - Synchronizes memory and atomics between web workers and browser threads to enable multi-threaded execution.
- Attribute-Based Mappings - Uses source-level metadata attributes to automate the generation of function signatures and type mappings.
- Runtime Exception Handling - Wraps exported functions to catch JavaScript exceptions and translate them into native Rust error types.
- Cross-Runtime Closure Wrapping - Wraps internal Rust closures for use in the host environment with options for ownership transfer.
- Cross-Runtime Exception Translation - Intercepts native Wasm traps and JavaScript errors to translate them into language-specific error types across the boundary.
- TypeScript Type Definitions - Creates automatic TypeScript type bindings to provide autocomplete and static checking for compiled modules.
- Foreign Function Interface - Facilitates interaction between Wasm and JavaScript.
