The Rust and WebAssembly working group was founded and now provides a lot of tooling, documentation, tutorials and other material. For a complete introduction to Rust and WebAssembly check out the Rust 🦀 and WebAssembly 🕸 book.

Oxidizing Source Maps with Rust and WebAssembly

Nick Fitzgerald and Tom Tromey rewrote one of the most performance-sensitive code paths for source map parsing, that's used in JavaScript debuggers and other applications. Using Rust compiled to WebAssembly they were able to run more than 5 times faster for real-world use cases. All work is based on the wasm32-unknown-unkown target of Rust. Along the way they discovered a few shortcomings of this target and some bugs as well.

Making WebAssembly even faster: Firefox’s new streaming and tiering compiler

Lin Clark wrote another illustrated post on WebAssembly, this time introducing the new streaming compilation feature coming to Firefox 58. With this, WebAssembly can be compiled while it is streamed over the network and it will be ready to execute as soon as all the code is there. In combination with the baseline compiler in Firefox this brings another boost to running WebAssembly.

Tooling

Useful new tools came out of Nick's and Tom's work as well. One of these is wasm-snip, a tool to replace unused functions, that neither the compiler nor wasm-gc were able to remove with no-ops. This should get rid of some of the code bloat still in the module. Once we get a proper linker and improved compiler this will hopefully be unnecessary.

emk started a new tool to analyze size of WebAssembly modules more easily: wasm-bloat.

If you're compiling to WebAssembly also take a look at binaryen, which has tools like wasm-opt for even more optimization.

A point of coordination for all things rust+wasm

Aaron started a new repository to coordinate the development of Rust and its Wasm backend. With already two dozen issues opened, there's a lot going on. Jump into the discussion and shape how Rust and WebAssembly work together.

More examples

Daniel pointed me to two new demos of Rust and WebAssembly.

wasm-astar is a A* Pathfinding example, showed on an interactive map and some writing about Jake's experience working on it.

Koute wrote pinky, a fully working NES emulator written in Rust. Most excitingly there's also a Web frontend, running WebAssembly, to play your favourite game right in the browser: pinky-web.

Do you have another cool thing showing Rust & WebAssembly? Let me know by opening an issue.

Rust and WebAssembly With Turtle

With a bit more effort it might be possible to provide a Playground-like environment to run and code in the browser.

YEW - a framework for client-side web-apps

Inspired by Elm and ReactJS it has a MVC approach, a virtual DOM, HTML templates with Rust inside and data conversions built-in. And apparently it's fast as well as benchmarks show.

Support for Rust/Wasm in Parcel

Two weeks ago initial support for Rust and Wasm landed in Parcel, a web application bundler. It can automatically (re-)compile your Rust sources when they change and import the resulting Wasm module in your JavaScript code.

wasm-bindgen

A CLI and Rust dependency that will generate the necessary JavaScript bindings to your Rust code, so you can skip writing most of the boilerplate (boilerplate such as wasm-experiments). It generates TypeScript for now, which gives you proper types on the JavaScript side as well.

stdweb and cargo-web

stdweb, "a standard library for the client-side Web" gained support for wasm32-unknown-unknown in December, including a js! macro to call into JavaScript functions from your Rust code. In combination with cargo-web, a cargo subcommand taking care of the compile step, this allows for powerful new web applications implemented in Rust. The above mentioned YEW is built on top of stdweb.

More

People are playing around with the new small WebAssembly target more and more.

• Porting a roguelike game to WebAssembly. - A detailed post on what it took to port the game to the web browser
• Try to make gluon compile compile to WASM - Gluon is a embeddable language written in Rust
• Implement extensible syscall interface for wasm - An attempt to introduce a syscall interface in order to interact with the the runtime environment

You did something with Rust and WebAssembly? Let us know!

Read how he did it:

Writing a CHIP-8 emulator with Rust and WebAssembly

The post contains a detailed break down of how to write an emulator, along with the challenges of sharing data between Rust and WebAssembly.

Import memory

I also added another canvas demo showing the FizzleFade effect with a Feistel network.

Rust and the case for WebAssembly in 2018

The future of Rust & WebAssembly definitely needs a lot of work, but we're off to a good start to make Rust the language of choice here.

Semver on the web with Rust and WebAssembly

It has less features, but otherwise fully working.

Writing a Brainfuck Interpreter in Rust (and WebAssembly)

The source is available on GitHub: github.com/shritesh/brainfuck-rs-wasm and a live version available online.

Read how he did it:

Rocket - A Rust game running on WASM

The post includes the game running right there in the browser.

Canvas example

Caution: The example will display a flickering image after you press the start button.

See the included comments and documentation on how it works.

Factorial example

(This also adds proper deallocation of the formatted strings)

Minimal working example

The resulting WebAssembly modules is only 108 bytes big. Consider that minimal.

Once you install that nightly (or any later one from now on), you can compile to WebAssembly without additional tools:

rustup update
rustup target add wasm32-unknown-unknown --toolchain nightly
rustc +nightly --target wasm32-unknown-unknown -O hello.rs

Support & documentation is still a bit limited, but we're working to expand in this area. The Rust compiler also does not have a proper linker just now, so final WebAssembly modules will be quite big. Alex wrote a small tool to reduce the size:

cargo install --git https://github.com/alexcrichton/wasm-gc
wasm-gc hello.wasm small-hello.wasm

You can find the full instruction in the wasm-32-unknown-unknown setup guide.

If you want to contribute with examples, documentation, articles or other resources open an issue or pull request on github.com/badboy/hellorust.

This site will collect resources, guides, articles and links around Rust & WebAssembly. If you want to help or have more resources we should add, open an issue or send a Pull Request to github.com/badboy/hellorust.

To get started, head over to the Setup section or take a look at some example code.