If you've written some Rust code, you can compile it into WebAssembly! This tutorial takes you through all you need to know to compile a Rust project to wasm and use it in an existing web app.

Rust and WebAssembly use cases

There are two main use-cases for Rust and WebAssembly:

  • To build an entire application — an entire web app based in Rust!
  • To build a part of an application — using Rust in an existing JavaScript frontend.

For now, the Rust team is focusing on the latter case, and so that's what we'll cover here. For the former case, check out projects like yew.

In this tutorial, we'll build an npm package using wasm-pack, a tool for building npm packages in Rust. This package will only contain WebAssembly and JavaScript code, and so the users of the package won't need Rust installed. They may not even notice that it's written in WebAssembly!

Rust Environment Setup

Let's go through all the required steps to get our environment set up.

Install Rust

Install Rust by going to the Install Rust page and following the instructions. This will install a tool called "rustup", which lets you manage multiple versions of Rust. By default, it installs the latest stable Rust release, which you'll want to use for general Rust development. Rustup installs rustc, the Rust compiler, as well as cargo, Rust's package manager, rust-std, Rust's standard libraries, and some helpful docs — rust-docs.

Note: Pay attention to the post-install note about needing to have cargo's bin directory in your system PATH. This should be added automatically, but you'll need to restart your terminal for it to take effect.


To build our package, we'll need an additional tool, wasm-pack. This will help us compile our code to WebAssembly, as well as produce the right packaging for npm. To download and install it, enter the following command into your terminal:

$ cargo install wasm-pack

Install Node.js and get an npm account

We'll be building an npm package in this tutorial, and so you'll need to have Node.js and npm installed. Additionally, we'll be publishing our package to npm, and so you'll need an npm account as well. They're free! You don't technically have to publish the package, but using it is much easier that way, and so we'll be assuming that you do in this tutorial.

To get Node.js and npm, go to the Get npm! page and follow the instructions. When it comes to picking a version, choose any one you'd like; this tutorial isn't version-specific.

To get an npm account, go to the npm signup page and fill out the form.

Next, at the command line run npm adduser:

$ npm adduser
Username: yournpmusername
Email: (this IS public) you@example.com

You'll need to fill out your own username, password, and email. If it worked, you'll see this printed:

Logged in as yournpmusername on https://registry.npmjs.org/.

If something didn't work, contact npm to get it sorted.

Building our WebAssembly npm package

Enough setup, let's create a new package in Rust. Go to wherever you keep your personal projects, and do this:

$ cargo new --lib hello-wasm
     Created library `hello-wasm` project

This will create a new library in a subdirectory named hello-wasm with everything you need to get going:

+-- Cargo.toml
+-- src
    +-- lib.rs

First up, we have Cargo.toml; this is the way that we can configure our build. If you've used Gemfile from Bundler or package.json from npm , you'll feel right at home; Cargo works in a similar manner to both of them.

Next, Cargo has generated some Rust code for us in src/lib.rs:

mod tests {
    fn it_works() {
        assert_eq!(2 + 2, 4);

We won't use this test code at all, so go ahead and delete it.

Let's write some Rust!

Let's put this code into src/lib.rs instead:

extern crate wasm_bindgen;

use wasm_bindgen::prelude::*;

extern {
    pub fn alert(s: &str);

pub fn greet(name: &str) {
    alert(&format!("Hello, {}!", name));

This is the contents of our Rust project. It has three main parts, let's talk about them in turn. We'll give a high-level explanation here, and gloss over some details; to learn more about Rust, please check the free online book The Rust Programming Language.

Using wasm-bindgen to communicate between Rust and JavaScript

The first part looks like this:

extern crate wasm_bindgen;

use wasm_bindgen::prelude::*;

The first line says "hey Rust, we're using a library called wasm_bindgen." Libraries are called "crates" in Rust, and we're using an external one, so "extern".

Get it? Cargo ships crates.

The third line contains a use command, which imports code from a library into your code. In this case, we're importing everything in the wasm_bindgen::prelude module. We'll use these features in the next section.

Before we move on to the next section, we should talk a bit more about wasm-bindgen.

wasm-pack uses wasm-bindgen, another tool, to provide a bridge between the types of JavaScript and Rust. It allows JavaScript to call a Rust API with a string, or a Rust function to catch a JavaScript exception.

We'll be using wasm-bindgen's functionality in our package. In fact, that's the next section!

Calling external functions in JavaScript from Rust

The next part looks like this:

extern {
    pub fn alert(s: &str);

The bit inside the #[] is called an "attribute", and it modifies the next statement somehow. In this case, that statement is an extern, which tells Rust that we want to call some externally defined functions. The attribute says "wasm-bindgen knows how to find these functions".

The third line is a function signature, written in Rust. It says "the alert function takes one argument, a string named s."

You may have a suspicion as to what this function is, and your suspicion may be right: this is the alert function provided by JavaScript! We'll be calling this function in the next section.

Whenever you want to call new JavaScript functions, you can write them in here, and wasm-bindgen will take care of setting everything up for you. Not everything is supported yet, but we're working on it! Please file bugs if something is missing.

Producing Rust functions that JavaScript can call

The final part is this one:

pub fn greet(name: &str) {
    alert(&format!("Hello, {}!", name));

Once again, we see the #[wasm_bindgen] attribute. In this case, it's not modifying an extern block, but a fn; this means that we want this Rust function to be able to be called by JavaScript. It's the opposite of extern: these aren't the functions we need, but the functions we're giving out to the world!

This function is named greet, and takes one argument, a string (written &str), name. It then calls the alert function we asked for in the extern block above. It passes a call to the format! macro, which lets us concatenate strings.

format! takes two arguments in this case, a format string, and a variable to put in it. The format string is the "Hello, {}!" bit. It contains {}s, where variables will be interpolated. The variable we're passing is name, the argument to the function, so if we call greet("Steve") we should see "Hello, Steve!".

This is passed to alert(), so when we call this function we should see an alert box with "Hello, Steve!" in it!

Now that our library is written, let's build it.

Compiling our code to WebAssembly

To compile our code correctly, we first need to configure it with Cargo.toml. Open this file up, and change its contents to look like this:

name = "hello-wasm"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
description = "A sample project with wasm-pack"
license = "MIT/Apache-2.0"
repository = "https://github.com/yourgithubusername/hello-wasm"

crate-type = ["cdylib"]

wasm-bindgen = "0.2"

You'll need to fill in your own repository, and Cargo should have filled in authors based on the info git uses.

The big part to add is the stuff at the bottom. The first part — [lib] — tells Rust to build a cdylib version of our package; we won't get into what that means in this tutorial. For more, consult the Cargo and Rust Linkage documentation.

The second section is the [dependencies] section. Here's where we tell Cargo what version of wasm-bindgen we want to depend on; in this case, that's any 0.2.z version (but not 0.3.0 or above).

Building the package

Now that we've got everything set up, let's build! Type this into your terminal:

$ wasm-pack build --scope mynpmusername

This will do a number of things (and they take a lot of time, especially the first time you run wasm-pack). To learn about them in detail, check out this blog post on Mozilla Hacks. In short, wasm-pack build will:

  1. Compile your Rust code to WebAssembly.
  2. Run wasm-bindgen on that WebAssembly, generating a JavaScript file that wraps up that WebAssembly file into a module npm can understand.
  3. Create a pkg directory and move that JavaScript file and your WebAssembly code into it.
  4. Read your Cargo.toml and produce an equivalent package.json.
  5. Copy your README.md (if you have one) into the package.

The end result? You have an npm package inside of the pkg directory.

A digression about code size

If you check out the generated WebAssembly code size, it may be a few hundred kilobytes. We haven't instructed Rust to optimize for size at all, and doing so cuts down on the size a lot. This is off-topic for this tutorial, but if you'd like to learn more, check out the Rust WebAssembly Working Group's documentation on Shrinking .wasm Size.

Publishing our package to npm

Let's publish our new package to the npm registry:

$ cd pkg
$ npm publish --access=public

We now have an npm package, written in Rust, but compiled to WebAssembly. It's ready for use from JavaScript, and doesn't require the user to have Rust installed; the code included was the WebAssembly code, not the Rust source!

Using our package on the web

Let's build a website that uses our new package! Many people use npm packages through various bundler tools, and we'll be using one of them, webpack, in this tutorial. It's only slightly more complex, and shows off a more realistic use-case.

Let's move back out of the pkg directory, and make a new directory, site, to try this out in:

$ cd ../..
$ mkdir site
$ cd site

Create a new file, package.json, and put the following code in it:

  "scripts": {
    "serve": "webpack-dev-server"
  "dependencies": {
    "@mynpmusername/hello-wasm": "^0.1.0"
  "devDependencies": {
    "webpack": "^4.25.1",
    "webpack-cli": "^3.1.2",
    "webpack-dev-server": "^3.1.10"

Note that you'll need to fill in your own username, after the @, in the dependencies section.

Next, we need to configure Webpack. Create webpack.config.js and put the following in it:

const path = require('path');
module.exports = {
  entry: "./index.js",
  output: {
    path: path.resolve(__dirname, "dist"),
    filename: "index.js",
  mode: "development"

Now we need an HTML file; create an index.html and give it the following contents:

<!DOCTYPE html>
    <meta charset="utf-8">
    <title>hello-wasm example</title>
    <script src="./index.js"></script>

Finally, create the index.js referenced in the HTML file and give it these contents:

const js = import("./node_modules/@yournpmusername/hello-wasm/hello_wasm.js");
js.then(js => {

Note that you need to fill in your npm username again.

This imports our module from the node_modules folder. This isn't considered a best practice, but this is a demo, so we'll work with it for now. Once it's loaded, it calls the greet function from that module, passing "WebAssembly" as a string. Note how there's nothing special here, yet we're calling into Rust code! As far as the JavaScript code can tell, this is just a normal module.

We're done making files! Let's give this a shot:

$ npm install
$ npm run serve

This will start up a web server. Load up http://localhost:8080 and you should see an alert box come on the screen, with Hello, WebAssembly! in it! We've successfully called from JavaScript into Rust, and from Rust into JavaScript.


This is the end of our tutorial; we hope you've found it useful.

There's lots of exciting work going on in this space; if you'd like to help make it even better, check out the Rust Webassembly Working Group.

Document Tags and Contributors

Last updated by: ExE-Boss,