WebAssembly.Module() constructor
Baseline
Widely available
*
This feature is well established and works across many devices and browser versions. It’s been available across browsers since October 2017.
* Some parts of this feature may have varying levels of support.
A WebAssembly.Module() constructor creates a new Module
object containing stateless WebAssembly code that has already been compiled by the
browser and can be efficiently shared with Workers, and instantiated multiple times.
The WebAssembly.Module() constructor function can be called to
synchronously compile given WebAssembly binary code. However, the primary way to get a
Module is through an asynchronous compilation function like
WebAssembly.compile().
Warning:
Since compilation for large modules can be expensive,
developers should only use the Module() constructor when synchronous
compilation is absolutely required; the asynchronous
WebAssembly.compileStreaming() method should be used at all other times.
Note: Webpages that have strict Content Security Policy (CSP) might block WebAssembly from compiling and executing modules. For more information on allowing WebAssembly compilation and execution, see the script-src CSP.
Syntax
new WebAssembly.Module(bufferSource)
new WebAssembly.Module(bufferSource, compileOptions)
Parameters
bufferSource-
A typed array or ArrayBuffer containing the binary code of the Wasm module you want to compile.
compileOptionsOptional-
An object containing compilation options. Properties can include:
builtinsOptional-
An array of strings that enables the usage of JavaScript builtins in the compiled Wasm module. The strings define the builtins you want to enable. Currently the only available value is
"js-string", which enables JavaScript string builtins. importedStringConstantsOptional-
A string specifying a namespace for imported global string constants. This property needs to be specified if you wish to use imported global string constants in the Wasm module.
Exceptions
- If the parameter is not of the correct type or structure, a
TypeErroris thrown. - If compilation fails, the constructor rejects with a
WebAssembly.CompileError. - Some browsers may throw a
RangeError, as they prohibit compilation and instantiation of Wasm with large buffers on the UI thread.
Examples
Synchronously compiling a WebAssembly module
const importObject = {
my_namespace: {
imported_func(arg) {
console.log(arg);
},
},
};
function createWasmModule(bytes) {
return new WebAssembly.Module(bytes);
}
fetch("simple.wasm")
.then((response) => response.arrayBuffer())
.then((bytes) => {
const mod = createWasmModule(bytes);
WebAssembly.instantiate(mod, importObject).then((result) =>
result.exports.exported_func(),
);
});
Enabling JavaScript builtins and global string imports
This example enables JavaScript string builtins and imported global string constants when compiling a Wasm module via the Module() constructor, which is then instantiated with instantiate(). It then calls the exported main() function, which logs "hello world!" to the console. See it running live.
const importObject = {
// Regular import
m: {
log: console.log,
},
};
const compileOptions = {
builtins: ["js-string"], // Enable JavaScript string builtins
importedStringConstants: "string_constants", // Enable imported global string constants
};
fetch("log-concat.wasm")
.then((response) => response.arrayBuffer())
.then((bytes) => {
const module = new WebAssembly.Module(bytes, compileOptions);
WebAssembly.instantiate(module, importObject).then((instance) =>
instance.exports.main(),
);
});
Specifications
| Specification |
|---|
| WebAssembly JavaScript Interface # dom-module-module |
Browser compatibility
| desktop | mobile | server | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Module() constructor
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
compileOptions parameter
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support
- No support
- No support