A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://rustwasm.github.io/docs/wasm-bindgen/reference/deployment.html below:

Deployment - The `wasm-bindgen` Guide

  1. Introduction
  3. 1. Examples
    1. 1.1. Hello, World!
    2. 1.2. Using console.log
    3. 1.3. Small Wasm files
    4. 1.4. Without a Bundler
    5. 1.5. Synchronous Instantiation
    6. 1.6. Importing functions from JS
    7. 1.7. Working with char
    8. 1.8. js-sys: WebAssembly in WebAssembly
    9. 1.9. web-sys: DOM hello world
    10. 1.10. web-sys: Closures
    11. 1.11. web-sys: performance.now
    12. 1.12. web-sys: using fetch
    13. 1.13. web-sys: Weather report
    14. 1.14. web-sys: canvas hello world
    15. 1.15. web-sys: canvas Julia set
    16. 1.16. web-sys: WebAudio
    17. 1.17. web-sys: WebGL
    18. 1.18. web-sys: WebSockets
    19. 1.19. web-sys: WebRTC DataChannel
    20. 1.20. web-sys: requestAnimationFrame
    21. 1.21. web-sys: A Simple Paint Program
    22. 1.22. web-sys: Wasm in Web Worker
    23. 1.23. Parallel Raytracing
    24. 1.24. Wasm Audio Worklet
    25. 1.25. web-sys: A TODO MVC App
  5. 2. Reference
    1. 2.1. Deployment
    2. 2.2. JS snippets
    3. 2.3. Static JS Objects
    4. 2.4. Passing Rust Closures to JS
    5. 2.5. Receiving JS Closures in Rust
    6. 2.6. Promises and Futures
    7. 2.7. Iterating over JS Values
    8. 2.8. Arbitrary Data with Serde
    9. 2.9. Accessing Properties of Untyped JS Values
    10. 2.10. Working with Duck-Typed Interfaces
    11. 2.11. Command Line Interface
    12. 2.12. Optimizing for Size
    13. 2.13. Supported Rust Targets
    14. 2.14. Supported Browsers
    15. 2.15. Support for Weak References
    16. 2.16. Support for Reference Types
    17. 2.17. Supported Types
      1. 2.17.1. Imported JavaScript Types
      2. 2.17.2. Exported Rust Types
      3. 2.17.3. JsValue
      4. 2.17.4. Box<[T]> and Vec
      5. 2.17.5. *const T and *mut T
      6. 2.17.6. NonNull
      7. 2.17.7. Numbers
      8. 2.17.8. bool
      9. 2.17.9. char
      10. 2.17.10. str
      11. 2.17.11. String
      12. 2.17.12. Number Slices
      13. 2.17.13. Boxed Number Slices
      14. 2.17.14. Result<T, E>
    19. 2.18. #[wasm_bindgen] Attributes
      1. 2.18.1. On JavaScript Imports
        1. 2.18.1.1. catch
        2. 2.18.1.2. constructor
        3. 2.18.1.3. extends
        4. 2.18.1.4. getter and setter
        5. 2.18.1.5. final
        6. 2.18.1.6. indexing_getter, indexing_setter, and indexing_deleter
        7. 2.18.1.7. js_class = "Blah"
        8. 2.18.1.8. js_name
        9. 2.18.1.9. js_namespace
        10. 2.18.1.10. method
        11. 2.18.1.11. module = "blah"
        12. 2.18.1.12. raw_module = "blah"
        13. 2.18.1.13. no_deref
        14. 2.18.1.14. static_method_of = Blah
        15. 2.18.1.15. structural
        16. 2.18.1.16. typescript_type
        17. 2.18.1.17. variadic
        18. 2.18.1.18. vendor_prefix
      3. 2.18.2. On Rust Exports
        1. 2.18.2.1. constructor
        2. 2.18.2.2. js_name = Blah
        3. 2.18.2.3. js_class = Blah
        4. 2.18.2.4. readonly
        5. 2.18.2.5. skip
        6. 2.18.2.6. skip_jsdoc
        7. 2.18.2.7. start
        8. 2.18.2.8. main
        9. 2.18.2.9. typescript_custom_section
        10. 2.18.2.10. getter and setter
        11. 2.18.2.11. inspectable
        12. 2.18.2.12. skip_typescript
        13. 2.18.2.13. getter_with_clone
        14. 2.18.2.14. unchecked_return_type and unchecked_param_type
        15. 2.18.2.15. return_description and param_description
  7. 3. web-sys
    1. 3.1. Using web-sys
    2. 3.2. Cargo Features
    3. 3.3. Function Overloads
    4. 3.4. Type Translations
    5. 3.5. Inheritance
    6. 3.6. Unstable APIs
  9. 4. Testing with wasm-bindgen-test
    1. 4.1. Usage
    2. 4.2. Writing Asynchronous Tests
    3. 4.3. Testing in Headless Browsers
    4. 4.4. Continuous Integration
    5. 4.5. Coverage (Experimental)
  11. 5. Contributing to wasm-bindgen
    1. 5.1. Testing
    2. 5.2. Internal Design
      1. 5.2.1. JS Objects in Rust
      2. 5.2.2. Exporting a function to JS
      3. 5.2.3. Exporting a struct to JS
      4. 5.2.4. Importing a function from JS
      5. 5.2.5. Importing a class from JS
      6. 5.2.6. Rust Type conversions
      7. 5.2.7. Types in wasm-bindgen
    4. 5.3. js-sys
      1. 5.3.1. Testing
      2. 5.3.2. Adding More APIs
    6. 5.4. web-sys
      1. 5.4.1. Overview
      2. 5.4.2. Testing
      3. 5.4.3. Logging
      4. 5.4.4. Supporting More Web APIs
    8. 5.5. Publishing
    9. 5.6. Team
This documentation is no longer maintained at this domain, and is now maintained at wasm-bindgen.github.io instead. Deploying Rust and WebAssembly

At this point in time deploying Rust and WebAssembly to the web or other locations unfortunately isn't a trivial task to do. This page hopes to serve as documentation for the various known options, and as always PRs are welcome to update this if it's out of date!

The methods of deployment and integration here are primarily tied to the --target flag.

Value Summary bundler Suitable for loading in bundlers like Webpack web Directly loadable in a web browser nodejs Loadable via require as a Node.js CommonJS module deno Loadable using imports from Deno modules no-modules Like web, but older and doesn't use ES modules experimental-nodejs-module Loadable via import as a Node.js ESM module. Bundlers

--target bundler

The default output of wasm-bindgen, or the bundler target, assumes a model where the Wasm module itself is natively an ES module. This model, however, is not natively implemented in any JS implementation at this time. As a result, to consume the default output of wasm-bindgen you will need a bundler of some form.

Note: the choice of this default output was done to reflect the trends of the JS ecosystem. While tools other than bundlers don't support Wasm files as native ES modules today they're all very much likely to in the future!

Currently the only known bundler known to be fully compatible with wasm-bindgen is webpack. Most examples use webpack, and you can check out the hello world example online to see the details of webpack configuration necessary.

Without a Bundler

--target web or --target no-modules

If you're not using a bundler but you're still running code in a web browser, wasm-bindgen still supports this! For this use case you'll want to use the --target web flag. You can check out a full example in the documentation, but the highlights of this output are:

The CLI also supports an output mode called --target no-modules which is similar to the web target in that it requires manual initialization of the wasm and is intended to be included in web pages without any further postprocessing. See the without a bundler example for some more information about --target no-modules.

Node.js

--target nodejs

If you're deploying WebAssembly into Node.js (perhaps as an alternative to a native module), then you'll want to pass the --target nodejs flag to wasm-bindgen.

Like the "without a bundler" strategy, this method of deployment does not require any further postprocessing. The generated JS shims can be require'd just like any other Node module (even the *_bg Wasm file can be require'd as it has a JS shim generated as well).

Note that this method requires a version of Node.js with WebAssembly support, which is currently Node 8 and above.

Node.js Module

--target experemintal-nodejs-module

If you're deploying WebAssembly into Node.js as a JavaScript module, then you'll want to pass the --target experimental-nodejs-module flag to wasm-bindgen.

Like the "node" strategy, this method of deployment does not require any further postprocessing. The generated JS shims can be imported just like any other Node module.

Note that this method requires a version of Node.js with WebAssembly and module support, which is currently Node 12 and above.

Currently experimental. Target is expected to be changed before stabilization.

Deno

--target deno

To deploy WebAssembly to Deno, use the --target deno flag. To then import your module inside deno, use

// @deno-types="./out/crate_name.d.ts"
import { yourFunction } from "./out/crate_name.js";
NPM

If you'd like to deploy compiled WebAssembly to NPM, then the tool for the job is wasm-pack. More information on this coming soon!

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4