Open-source Rust projects categorized as WASM

WebAssembly (abbreviated WASM) is a binary instruction format for a stack-​based virtual machine. WebAssembly is an open standard that defines a portable binary-code format for executable programs, and a corresponding textual assembly language, as well as interfaces for facilitating interactions between such programs and their host environment.

Top 23 Rust WASM Projects

  • v86

    x86 PC emulator and x86-to-wasm JIT, running in the browser

    Project mention: WASI 0.2.0 and Why It Matters | | 2024-01-26

    > As a thought experiment, we're almost there! We could technically have `win95.img + bochs86vm.wasm + autorun.inf + msword.exe` wrapped in a "browser evaluator"

    I looked into this and... holy crap! We are there. Not for modern programs quite yet, sure, but this is amazing. You can use Windows 2000 from your browser.

  • egui

    egui: an easy-to-use immediate mode GUI in Rust that runs on both web and native

    Project mention: We sped up time series by 20-30x | | 2024-02-14

    FWIW, I opened an issue:


    Learn 300+ open source libraries for free using AI. LearnThisRepo lets you learn 300+ open source repos including Postgres, Langchain, VS Code, and more by chatting with them using AI!

  • RustPython

    A Python Interpreter written in Rust

    Project mention: FLaNK Stack Weekly 12 February 2024 | | 2024-02-12
  • wasmer

    🚀 The leading Wasm Runtime supporting WASIX, WASI and Emscripten

    Project mention: RustPython | | 2024-02-07
  • dioxus

    Fullstack GUI library for desktop, web, mobile, and more.

    Project mention: Container2wasm: Convert Containers to WASM Blobs | | 2024-01-03
  • tree-sitter

    An incremental parsing system for programming tools

    Project mention: An incremental parsing system for programming tools | | 2023-05-27
  • wasmtime

    A fast and secure runtime for WebAssembly

    Project mention: Howto: WASM runtimes in Docker / Colima | | 2024-01-12

    cpu: 4 disk: 60 memory: 12 arch: host hostname: colima autoActivate: true forwardAgent: false # I only tested this with 'docker', not 'containerd': runtime: docker kubernetes: enabled: false version: v1.24.3+k3s1 k3sArgs: [] network: address: true dns: [] dnsHosts: host.docker.internal: host.lima.internal # Added: # - containerd-snapshotter: true (meaning containerd will be used for pulling images) docker: features: buildkit: true containerd-snapshotter: true vmType: vz rosetta: true mountType: virtiofs mountInotify: false cpuType: host # This provisioning script installs build dependencies, WasmEdge and builds the WASM runtime shims for containerd. # NOTE: this takes a LOOONG time! provision: - mode: system script: | [ -f /etc/docker/daemon.json ] && echo "Already provisioned!" && exit 0 echo "Installing system updates:" apt-get update -y apt-get upgrade -y echo "Installing WasmEdge and runwasi build dependencies:" # NOTE: packages curl, git and python3 already installed: apt-get install -y make gcc build-essential pkgconf libtool libsystemd-dev libprotobuf-c-dev libcap-dev libseccomp-dev libyajl-dev libgcrypt20-dev go-md2man autoconf automake criu pkg-config libdbus-glib-1-dev libelf-dev libclang-dev libzstd-dev protobuf-compiler apt-get clean -y - mode: user script: | [ -f /etc/docker/daemon.json ] && echo "Already provisioned!" && exit 0 # # Setting vars for this script: # # Which WASM runtimes to install (wasmedge, wasmtime and wasmer are supported): WASM_RUNTIMES="wasmedge wasmtime wasmer" # # Location of the containerd config file: CONTAINERD_CONFIG="/etc/containerd/config.toml" # # Target location for the WASM runtimes and containerd shims ($TARGET/bin and $TARGET/lib): TARGET="/usr/local" # # Install rustup: # echo "Installing rustup for building runwasi:" curl --proto '=https' --tlsv1.2 -sSf | sh -s -- --default-toolchain none -y source "$HOME/.cargo/env" # # Install selected WASM runtimes and containerd shims: # [[ -z "${WASM_RUNTIMES// /}" ]] && echo "No WASM runtimes selected - exiting!" && exit 0 git clone echo "Installing WASM runtimes and building containerd shims: ${WASM_RUNTIMES}:" sudo mkdir -p /etc/containerd/ containerd config default | sudo tee $CONTAINERD_CONFIG >/dev/null for runtimeName in $WASM_RUNTIMES; do case $runtimeName in wasmedge) echo "Installing WasmEdge:" curl -sSfL | sudo bash -s -- -p $TARGET echo echo "`wasmedge -v` installed!" ;; wasmtime) echo "Installing wasmtime:" curl -sSfL | bash sudo cp .wasmtime/bin/* ${TARGET}/bin/ rm -rf .wasmtime echo "`wasmtime -V` installed!" ;; wasmer) echo "Installing wasmer:" curl -sSfL | sh sudo cp .wasmer/bin/* ${TARGET}/bin/ sudo cp .wasmer/lib/* ${TARGET}/lib/ rm -rf .wasmer echo "`wasmer -V` installed!" ;; *) echo "ERROR: WASM runtime $runtimeName is not supported!" exit 1 ;; esac cd runwasi echo "Building containerd-shim-${runtimeName}:" cargo build -p containerd-shim-${runtimeName} --release echo "Installing containerd-shim-${runtimeName}-v1:" sudo install ./target/release/containerd-shim-${runtimeName}-v1 ${TARGET}/bin sudo ln -sf ${TARGET}/bin/containerd-shim-${runtimeName}-v1 ${TARGET}/bin/containerd-shim-${runtimeName}d-v1 sudo ln -sf ${TARGET}/bin/containerd-shim-${runtimeName}-v1 ${TARGET}/bin/containerd-${runtimeName}d echo "containerd-shim-${runtimeName} installed." cd .. echo "[plugins.\"io.containerd.grpc.v1.cri\".containerd.runtimes.${runtimeName}]" | sudo tee -a $CONTAINERD_CONFIG >/dev/null echo " runtime_type = \"io.containerd.${runtimeName}.v1\"" | sudo tee -a $CONTAINERD_CONFIG >/dev/null done echo "containerd WASM runtimes and shims installed." # # Restart the systemctl services to pick up the installed shims. # NOTE: We need to 'stop' docker because at this point the actual daemon.json config is not yet provisioned: # echo "Restarting/reloading docker/containerd services:" sudo systemctl daemon-reload sudo systemctl restart containerd sudo systemctl stop docker sshConfig: true mounts: [] env: {}

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  • slint

    Slint is a declarative GUI toolkit to build native user interfaces for Rust, C++, or JavaScript apps.

    Project mention: Deno in 2023 | | 2024-02-05

    Currently, we do it by using binaries through napi-rs so we can bring in a window using the platform native API. And then we do some hack to merge the event loops.

    But if Deno supports bringing up a window directly, this means we can just ship wasm instead of native binary for all platform. And also I hope event loop integration will be simplified.

    Although we'd also need more API than just showing a window (mouse and keyboard input, accessibility, popup window, system tray, ...)


  • genact

    🌀 A nonsense activity generator

    Project mention: I'm not in a hurry, let's make it fun | /r/linuxmemes | 2023-05-05
  • wasm-bindgen

    Facilitating high-level interactions between Wasm modules and JavaScript

    Project mention: If the native speed DOM/Web API for Rust becomes a reality, would you be willing to build your web apps with Rust and HTML/CSS? | /r/rust | 2023-12-05

    Another strange issue could be seen in the strict class heritage organized definition of the DOM, which can not be handled very well by rust because of a still unsolved bindgen issue (#210).

  • burn

    Burn is a new comprehensive dynamic Deep Learning Framework built using Rust with extreme flexibility, compute efficiency and portability as its primary goals.

    Project mention: Transitioning From PyTorch to Burn | | 2024-02-14

    [package] name = "resnet_burn" version = "0.1.0" edition = "2021" [dependencies] burn = { git = "", rev = "75cb5b6d5633c1c6092cf5046419da75e7f74b11", features = ["ndarray"] } burn-import = { git = "", rev = "75cb5b6d5633c1c6092cf5046419da75e7f74b11" } image = { version = "0.24.7", features = ["png", "jpeg"] }

  • wasm-pack

    📦✨ your favorite rust -> wasm workflow tool!

    Project mention: Rust + WASM + Typescript [+ React] | /r/rust | 2023-07-18

    For a much simpler but less flexible approach there's wasm-pack for creating JS packages from Rust, and wasm-bindgen for easy interop. Both have very good documentation.

  • lunatic

    Lunatic is an Erlang-inspired runtime for WebAssembly

    Project mention: Spin 2.0 – open-source tool for building and running WASM apps | | 2023-11-04

    you can check out for that

  • boa

    Boa is an embeddable and experimental Javascript engine written in Rust. Currently, it has support for some of the language.

    Project mention: A list of JavaScript engines, runtimes, interpreters | /r/learnjavascript | 2023-12-10


  • winit

    Window handling library in pure Rust

    Project mention: Linux version of Warp terminal is here | | 2024-02-22

    Hi! I’m Aloke, an engineer at Warp.

    I’m really excited to share that Warp is now available on Linux! If you’re interested in trying it out, you can download Warp:

    Building Warp on Linux was quite an undertaking. Warp uses a custom Rust-based UI framework that we built in house and renders natively on the GPU. To get Warp running on Linux, we built a version of our UI framework that supports winit [1] as a windowing backend. We also built a version of our renderer that uses wgpu [2]. Reducing complexity by using these well-supported, cross platform, frameworks let us bootstrap a version of Linux quicker than expected and should make it easier to build Warp for other platforms (like Windows).

    Please let me know what you think! Happy to answer any questions, either about the product or about technical challenges.


  • Seed

    A Rust framework for creating web apps

    Project mention: Yew alternatives | /r/learnrust | 2023-06-13

    Practically every Rust web frontend I've seen takes a react-like approach, with "hooks" to store all of the state in. The now-abandoned Seed and Yew's struct components use a message-passing approach, where the state is stored as member variables on the struct representing the component that are updated based on messages dispatched by event handlers. There's also egui, which has a completely different paradigm that involves making the UI from scratch every frame based on the app's current state. It's not a web framework the same way as the others, but it can draw its UI to a web canvas just fine.

  • krustlet

    Kubernetes Rust Kubelet

    Project mention: WASM Instructions | | 2024-02-18

    Oh it’s certainly looking like that IMO.

    You can run wasm in k8s:

    Docker itself can run wasm:

    There are a few serverless runtimes based on wasm:

    A lot of those are powered by wasmtime or WasmEdge.

    If you’re wanting to be able to just pull down a random app and run it as wasm, that’s inherently harder with wasm, because you have to recompile, and amazing compiling stuff is always harder than it should be. For example I compiled jq to wasm to other day, so you dont have to worry (as much) about the CVEs that was issued recently.

  • extism

    The framework for building with WebAssembly (wasm). Easily load wasm modules, move data, call functions, and build extensible apps.

    Project mention: Show HN: Now my pet programming language can run in the browser | | 2024-02-10

    It may just be my own unique obsession to peek at the internals of .wasm, but if anyone else is curious:

    u/nbittich - curious if you've tried to use your language as as a scripting language inside other apps? I took a peak at your browser wasm environment, and think we could hook up the `compute` entrypoint you have here[0], but I'm not certain what the `ctx` does without going super deep, and if it could be passed into an Extism function[1] (which is how I'd try to run it from within 16+ other languages).



  • Rhai

    Rhai - An embedded scripting language for Rust.

    Project mention: RustPython | | 2024-02-07
  • lldap

    Light LDAP implementation

    Project mention: Keycloak SSO with Docker Compose and Nginx | | 2024-02-11

    Good to hear, I think it'll make many users happy. For me, I've migrated back to Authelia. I moved to authentik because at the time Authelia had no user management. After all of authentik's sharp edges, I've found lldap[0], and was able to implement a pilot in a few hours. I haven't looked back, since everything was converted.


  • trunk

    Build, bundle & ship your Rust WASM application to the web.

    Project mention: Why Is the Front End Stack So Complicated? | | 2023-10-16

    I've been using Rust and WASM for my latest front-end project, and I think this setup is a viable alternative to commonly used JS frameworks for those willing to put in some effort to ramp up on new technology. Addressing the concerns from the article:

    "No universal import system" - Rust has it's own module system and Cargo is used for managing dependencies, no need to worry about different module systems.

    "Layers of minification, uglification, and transpilation." Just compile Rust to WASM file for the browser, same as using any other compile target.

    "Wildly different environments." Something that you'll still need to deal with. Some runtime dependencies are system-specific (code running on the browser usually needs access to Web APIs, and JavaScript, code running on the server can't access WebAPIs but can access the system clock and filesystem. Sometimes separate libraries or separate runtime configs are needed (e.g. configurable time source)

    "Overemphasis on file structure." Not a problem for imports, but you may still have file structure dependencies things like CSS, image resources etc.

    "Configuration hell." Pretty much non-existent once you have your Rust compiler setup locally.

    "Development parity." Just use trunk:, to watch, build and serve, config is minimal.

  • black-hat-rust

    Applied offensive security with Rust -

    Project mention: Cloudflare for Speed and Security | /r/CloudFlare | 2023-10-20

    Bonuses: If you purchase Cloudflare for Speed and Security before November 4, 2023, you'll get my bestseller, Black Hat Rust, for free! Yes, you read it right, two books for less than the price of one!

  • artichoke

    💎 Artichoke is a Ruby made with Rust

  • WorkOS

    The modern API for authentication & user identity. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

NOTE: The open source projects on this list are ordered by number of github stars. The number of mentions indicates repo mentiontions in the last 12 Months or since we started tracking (Dec 2020). The latest post mention was on 2024-02-22.

Rust WASM related posts


What are some of the best open-source WASM projects in Rust? This list will help you:

Project Stars
1 v86 18,861
2 egui 18,522
3 RustPython 17,118
4 wasmer 17,094
5 dioxus 15,895
6 tree-sitter 15,339
7 wasmtime 13,969
8 slint 13,547
9 genact 7,915
10 wasm-bindgen 7,125
11 burn 6,228
12 wasm-pack 5,777
13 lunatic 4,492
14 boa 4,475
15 winit 4,083
16 Seed 3,779
17 krustlet 3,520
18 extism 3,515
19 Rhai 3,346
20 lldap 3,275
21 trunk 3,067
22 black-hat-rust 2,998
23 artichoke 2,980
The modern API for authentication & user identity.
The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.