Lib.rs

wasm-encoder

A low-level WebAssembly encoder

wasm-bindgen

Easy support for interacting between JS and Rust

ts-rs

generate typescript bindings from rust types

wasmtime

High-level API to expose the Wasmtime runtime

deno_graph

Module graph analysis for deno

range-set-blaze

Integer sets as fast, sorted integer ranges; Maps with integer-range keys; Full set operations

wasmi

WebAssembly interpreter

wasmtime-asm-macros

Macros for defining asm functions in Wasmtime

console_error_panic_hook

A panic hook for wasm32-unknown-unknown that logs panics to console.error

web-time

Drop-in replacement for std::time for Wasm in browsers

edgee

The full-stack edge platform for your edge oriented applications

trunk

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

extism

runtime and Rust SDK

tsify

generating TypeScript definitions from rust code

wit-component

Tooling for working with *.wit and component files together

js-sys

Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on #[wasm_bindgen] using the wasm-bindgen crate

wasm-timer

Abstraction over std::time::Instant and futures-timer that works on WASM

wasmtimer

Time utils from std::time, tokio::time and tokio_util::time on WASM targets

tsify-next

generating TypeScript definitions from rust code

tonic-web-wasm-client

grpc-web implementation for use by tonic clients in browsers via webassembly

wasix

API bindings for Rust

yew-hooks

Hooks for the Yew web framework, inspired by react hook libs like streamich/react-use and alibaba/hooks

worker-build

be used as a custom build command for a Cloudflare Workers workers-rs project

wasmparser-nostd

event-driven library for parsing WebAssembly binary files

pi-async-rt

Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world

wasmer

High-performance WebAssembly runtime

wapc

An engine-pluggable WebAssembly Host Runtime implementing the waPC protocol

wasm-bindgen-rayon

Adapter for using Rayon-based concurrency on the Web

wadm

wasmCloud Application Deployment Manager: A tool for running Wasm applications in wasmCloud

dioxus-browser-extension-builder

A browser extension builder for dioxus

gloo

A modular toolkit for Rust and WebAssembly

wain

WebAssembly interpreter written in Safe Rust with zero dependencies

wasm-pkg-common

Wasm Package common types and configuration

wasm-streams

Bridging between web streams and Rust streams using WebAssembly

pax-message

Shared message structs used by Pax runtimes

detect-wasi

Detect if WASI can be run

witx-codegen

WITX code generator for WebAssembly guest modules

wasm-server-runner

cargo run for wasm programs

sqlite-wasm-rs

Provide sqlite solution for wasm32-unknown-unknown target

wasm_thread

An std thread replacement for wasm32 target

wasmer-sys-utils

Wasmer utilities for a sys environment

mathlab

A Powerful Math Library for Rust

finite-wasm

Guarantee deterministic limits on execution time and space resources made available to the WebAssembly programs in a runtime-agnostic way

indexed-db

Bindings to IndexedDB that default the transactions to aborting and can work multi-threaded

tokio_with_wasm

Mimicking tokio functionalities on web browsers

vertigo

Reactive Real-DOM library with SSR for Rust

turf

Build SCSS to CSS during compile time and inject those styles into your binary

wasmcloud-secrets-types

Types, traits, and structs for interacting with secrets in wasmCloud

frontwork

The TypeScript Framework using Deno & Webassembly

wasmprinter

Rust converter from the WebAssembly binary format to the text format

three-d

2D/3D renderer - makes it simple to draw stuff across platforms (including web)

wit-bindgen-cli

CLI tool to generate bindings for WIT documents and the component model

dora-ssr

The lib for building Dora SSR game as wasm32-wasi that runs on multi-platform Dora SSR engine

wasmtime-component-util

types and functions to support the component model in Wasmtime

chakra

A WebAssembly Runtime

leptos_server

RPC for the Leptos web framework

ratzilla

Build terminal-themed web applications with Ratatui and WebAssembly

wasi-preview1-component-adapter-provider

Embedded wasi-preview1-component-adapter binaries

watt

Runtime for executing Rust procedural macros compiled as WebAssembly

zduny-wasm-timer

Abstraction over std::time::Instant and futures-timer that works on WASM

time-format

Turn a Unix timestamp into date components or into a string

connection-string

Connection string parsing in Rust (and WebAssembly)

wasmparser

event-driven library for parsing WebAssembly binary files

stak-wasm

Stak Scheme in WebAssembly

wasm_runtime_layer

Compatibility interface for WASM runtimes

openapi-client-gen

Experimental OpenApi client generator for Rust with support for C-FFI and WASM

aes-wasm

AES-GCM, AES-OCB, AEGIS, AES-CTR, CMAC-AES for WebAssembly

aframe

High-level Aframe VR bindings for Rust WASM

exo

CLI for Exocore (Distributed applications framework)

wasm-pack-test-all

Wrapper for wasm-pack test that runs tests for all crates in a workspace or directory

sycamore

building reactive web apps in Rust and WebAssembly

wasmcloud-test-util

testing wasmCloud hosts, providers, and components

wnfs-wasm

WebNative Filesystem API (WebAssembly)

wat_server

WebAssembly Text Format language server

gear-wasm-optimizer

optimizing Gear programs

yewdux

Ergonomic state management for Yew applications

wgpu-3dgs-viewer

A 3D Gaussian splatting viewer written in Rust using wgpu

fp-bindgen

Bindings generator for full-stack WASM plugins

makepad-wasm-bridge

Makepad wasm bridge

percy-router

A router for client side web applications with server side rendering support

yewlish-testing-tools

A set of testing tools for the Yew framework

wasmgdb

gdb for WebAssembly

webui

early development Website UI framework and component library for quickly building websites with native support for Material UI standardization

wasm-opt

bindings

tauri-interop

Easily connect your rust frontend and backend without writing duplicate code

linera-parity-wasm

WebAssembly low-level format library

dioxus-charts

Chart components library for Dioxus

mathlikeanim-rs

creating mathematical animations

pixcil

Pixel art editor

async-timer

Timers for Rust async story

pax-chassis-web

Platform-specific chassis allowing Pax cartridges to be executed as Web apps

fusio-log

The append only log implementations

medea-jason

Client library for Medea media server

proto_pdk_test_utils

testing proto WASM plugins

containerd-shim-wasm

building containerd shims for wasm

fastly

Compute API

wrpc-transport-nats

wRPC NATS transport

wasm-instrument

Instrument and transform wasm modules

extism-manifest

Extism plug-in manifest crate

subsecond

A runtime hotpatching engine for Rust hot-reloading

wrpc-interface-http

wRPC HTTP interface

zuicon-material

Wrapper of material design icons for yew framework

wit-encoder

A WIT encoder for Rust

js-component-bindgen

JS component bindgen for transpiling WebAssembly components into JavaScript

n0-future

Number 0's way of doing rust futures. Re-exports what we think are useful abstractions and good implementations.

my-ecs

An Entity Component System (ECS) library

cargo-run-wasm

Trivially run wasm applications and examples in the browser

sledgehammer_bindgen

Fast batched js bindings

wonnx

ONNX runtime based on wgpu aimed at being a universal GPU runtime, written in Rust

tap-agent

Transaction Authorization Protocol (TAP)

macerator

Type and target-generic SIMD

shopify_function_wasm_api

High-level interface for interfacing with the Shopify Function Wasm API

leptos_config

Configuration for the Leptos web framework

guess-target

dioxus-web-component

Expose a Dioxus component as a Web Component

lwk_wasm

Liquid Wallet Kit - WASM

rexie

futures based wrapper around IndexedDB that compiles to webassembly

yew

A framework for creating reliable and efficient web applications

deterministic-wasi-ctx

A wasmtime-wasi WasiCtx implementation that is fully deterministic

js

Call JavaScript from WebAssembly

arrow-udf

User-defined function framework for arrow-rs

wasmtime-provider

A wasmtime engine provider for the waPC host

moq-web

Web implementation for MoQ utilizing WebAssembly+Typescript

pyodide-webassembly-runtime-layer

WASM runtime compatibility interface implementation for the webbrowser WebAssembly runtime, exposed through Pyodide

ankurah

Observable, event-driven state management for native and web

trunk-ng

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

wasmcv

Rust bindings for wasmCV computer vision interfaces based on WebAssembly

benchmark-simple

A tiny, super simple and portable benchmarking library

perseus

A lightning-fast frontend web dev platform with full support for SSR and SSG

wasmi_arena

Entity arena data structures for wasmi

cosmian_kms_client_wasm

Cosmian KMS Client Utilities for WASM

clg

A logger specifically designed for wasm32-unknown-unknown

metrum

Easily work with and compare temeratures in different units

dwind

Style your DOMINATOR applications using a tailwind-like syntax and utility class collection!

indxdb

A key-value database engine abstraction layer for IndexedDB running in WASM

dioxus-lib

Build fullstack web, desktop, and mobile apps with a single codebase

cargo-component-core

The core library for cargo-component

wasmtime-cranelift-shared

Base-level integration with Wasmtime and Cranelift

spow

Proof of Work for the Server and Client + WASM

casper-contract-schema

Data structures for the Casper Contract Schema

mapboxgl

Unofficial Rust binding for mapbox-gl-js

ffmpeg-wasi

FFMPEG for WebAssembly/WASI

dusk-transfer-contract-dd

Data driver for Dusk Transfer Contract

leptos_animated_for

<AnimatedFor /> component utilizing FLIP position transitions for Leptos

terrazzo

build dynamic web pages in Rust

cosmic-space

the Space portion of starlane as opposed to hyperspace

proxy-wasm

WebAssembly for Proxies

mvt-reader

decoding and reading mapbox vector tiles in Rust and WebAssembly

liblrs

manipulate linear referencing systems

prest

Progressive RESTful framework

leptos_hotkeys

that declaratively pairs keybindings with callbacks for Leptos applications

wasm-pack

📦✨ your favorite rust -> wasm workflow tool!

enfync

Environment-friendly async utilities

yew-lucide

Yew components for Lucide icons

ywasm

High performance implementation of the Yjs CRDT

jsonrpsee-wasm-client

JSON-RPC WASM client

kobold

Easy declarative web interfaces

wasm-pkg-client

Wasm package client

p2panda-rs

All the things a panda needs

debuginfo-split

Splits out the debugging informations

cbqn

Embed BQN in Rust via CBQN FFI

externref

Low-cost reference type shims for WASM modules

gloo-net

HTTP requests library for WASM Apps

bulwark-cli

Bulwark is a fast, modern, open-source web application security engine

axum-cloudflare-adapter

An adapter to easily run an Axum server in a Cloudflare worker

wasmer-wasix

WASI and WASIX implementation library for Wasmer WebAssembly runtime

opensass

🧩 A CLI to interact with the OpenSASS ecosystem

redpanda-transform-sdk-varint

Varint decoding for redpanda-transform-sdk

maia-wasm

Maia SDR WASM frontend

emscripten-functions

Rust-friendly bindings to various emscripten system functions

zen-expression

Zen Expression Language

arcjet-gravity

Gravity is a host generator for WebAssembly Components. It currently targets Wazero, a zero dependency WebAssembly runtime for Go.

rust-witness

Build a circom witness in Rust

wasi-nn

High-level Rust bindings for wasi-nn

we_clap

Web Enabled Command Line Argument Parser

lcax

open, machine and human-readable data format for exchanging LCA results

pagurus

Ultra-portable game engine suited for offline 2D games powered by WebAssembly

wasi

WASI API bindings for Rust

rocal

Full-Stack WASM framework

tracing-tunnel

Tunnelling tracing information across API boundary

spair

A framework for single-page application in Rust

trunkls

A language server for Trunk's custom HTML attributes

js-helpers

Easy interop utils for js objects in wasm

wit-parser

Tooling for parsing *.wit files and working with their contents

pulley-interpreter

The Pulley interpreter, its bytecode definition, encoder, decoder, and etc

stork-search

Impossibly fast web search, made for static sites

wasm3

Rust bindings for wasm3

wacker-daemon

wacker daemon cli

fluvio-smartmodule

Used by Fluvio SmartModule

ratatui-wasm-backend

Allows writing Ratatui terminal apps that target WASM

macroquad-particles

Visual effects editor based on macroquad and megaui

activity-build

Build tool for Discord activities in Rust

tja

TJA file parser written in Rust, working in Rust, Python, and WebAssembly

xoev-xwasser

"XOEV XWasser XML Standard"

github-languages

All GitHub's supported languages

stateroom-wasm

A macro for building a Stateroom service as a WebAssembly module

wasm-graph

WASM format graph representation

wasmedge-sdk

WasmEdge Runtime is a high-performance, extensible, and hardware optimized WebAssembly Virtual Machine for automotive, cloud, AI, and blockchain applications

leptos_form_tool

A declarative way to create forms for leptos

fluvio-controlplane-metadata

Metadata definition for Fluvio control plane

pit-rust-generator

Portal Interface Types for WebAssembly

portal-pc-waffle

Wasm Analysis Framework For Lightweight Experiments

natrix

Rust-First frontend framework

exocore

Distributed applications framework

combadge

makes Rust Web Workers easy

ratatui-wgpu

A wgpu based backend for ratatui

workflow-core

curated re-exports for async rust native and browser development

py-rs

generate python bindings from rust types

wasm_dep_analyzer

Wasm module dependency analysis for module resolution

cdumay_core

standard code

awsm_web

Wrappers for WASM

mrubyedge

mruby/edge is yet another mruby that is specialized for running on WASM

amll-lyric

一个歌词解析/生成模块，着重于歌词内容解析，支持多种格式

enarx

Tools for deploying WebAssembly into Enarx Keeps

bevy_simplenet_events

Event-based networking API built on bevy_simplenet

ansi2

wasm-pkg-core

Wasm Package Tools core libraries for wkg

leptos_styling

A powerful styling solution for Leptos applications that enables seamless integration of CSS and SCSS stylesheets with type-safe class names and zero runtime overhead

wasm-react

WASM bindings for React

qdrant_rest_client

The Qdrant SDK for WebAssembly

pulumi_gestalt_rust_adapter_wasm

Wasm Rust adapter for Pulumi Gestalt

kcr_extensions_istio_io

Kubernetes Custom Resource Bindings

inf-wasmparser

event-driven library for parsing Inferara non-deterministic WASM extension WebAssembly binary files

russh-util

Runtime abstraction utilities for russh

js-utils

Useful utilities to make development of browser-targeted Rust applications slightly less painful

boytacean-encoding

Codecs library for Boytacen

emscripten-val

wrapper around the emscripten/val api

wasm_to_png

convert a wasm file to png

lemmy-client

HTTP client for Lemmy

lumina-utils

Platform abstraction utilities used across lumina project

wasmer-interface-types-fl

WebAssembly Interface Types library for Wasmer

bounce

The uncomplicated state management library for Yew

tinywasm

A tiny WebAssembly interpreter

fluvio-spu-schema

Fluvio API for SPU

reqwest-h3

hitdns fork of higher level HTTP client library

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

unc-vm-runner

implements the specification of the interface that unc blockchain exposes to the smart contracts

sbbf-rs

Split block bloom filter implementation

percy-dom

A standalone Virtual DOM creation, diffing and patching implementation

dioxus-asset-resolver

Cross-platform asset resolver for manganis and dioxus

wasmedge_stable_diffusion

using stable diffusion functions when the Wasi is being executed on WasmEdge

dollgen

an unopinionated and extensible Static Site Generator, natively supporting liquid, markdoll, scss, and compiling rust to wasm

viceroy-lib

Viceroy implementation details

zuicon-ant

Wrapper of ant design icons for yew framework

wrpc-transport

wRPC core transport functionality

supabase-js-rs

Rust bindings for Supabase JavaScript library via WebAssembly

wasm-bindgen-utils

helpers that make working with wasm-bindgen easy

edgee-components-runtime

Edgee components runtime (using wasmtime)

wasm_component_layer

WebAssembly component model implementation for any backend

unit-wasm

WASM SDK for NGINX Unit

wasmi-validation

Wasm code validator

uni-app

native/wasm compatibility layer for window creation, input and filesystem

mechtron-host

Part of http://thecosmicinitiative.io This package--MECHTRON HOST--provides a wasm runtime

adana-script-wasm

namespaces aliases for command lines & basic scripting language

wasm-bindgen-test

Internal testing crate for wasm-bindgen

wasm2usharp

converting WebAssembly to UdonSharp

wasm-testsuite

Generic test harness for WebAssembly Runtimes

suparust

Supabase client for Rust with support for WASM

boa_interop

Interop utilities for integrating boa with a Rust host

worker-kv

Rust bindings to Cloudflare Worker KV Stores

custom-print

Define custom println and dbg macros in wasm and other targets

hang-wasm

Web implementation for MoQ utilizing WebAssembly+Typescript

otoroshi_rust_types

A CLI to create and build WASM binaries

fframes-editor-controller

Helper wasm module that provies fframes bindings for the web WASM editor

wasco

A minimal wasm compiler backend

wasmer-compiler-singlepass

Singlepass compiler for Wasmer WebAssembly runtime

wstd

An async standard library for Wasm Components and WASI 0.2

livid

lightweight frontend Rust crate for creating web apps via webassembly

dioxus-grpc

Easy interface for a gRPC client with Dioxus

polywrap-wasm-rs

Polywrap's Rust-Wasm Runtime

wasvy

Bevy WASM

wasm-css

Ergonomic WASM CSS Framework

densha

A modern full-stack web framework for Rust

ankurah-storage-postgres

Ankurah storage engine using Postgres

orca-wasm

A lightweight WebAssembly Transformation Library for the Component Model

rust-rectangle-dividing

A rectangle dividing algorithm written in Rust

cargo-wasix

Subcommand for Cargo to easily build code for wasm32-wasmer-wasi and wasm64-wasmer-wasi targets; aka. WASIX targets.

yew-webtransport

WebTransport is an API offering low-latency, bidirectional, client-server messaging

wasm-http-hyper

WebAssembly library that provides seamless integration between Node.js's IncomingMessage and Rust's hyper::Request

mlua-wasmer

Lua bindings and embedding of Wasmer, the high-performance WebAssembly runtime

hc-wasmer-compiler-singlepass

Singlepass compiler for Wasmer WebAssembly runtime

chakrapy

A Python interpreter written in Rust, designed for WebAssembly

wapc-guest

Guest SDK for building waPC-compliant WebAssembly Modules

lazy-js-bundle

A codegen library to bundle TypeScript into JavaScript without requiring a bundler to be installed

sdf-common

Stateful Dataflow constants and common utils

data-faking

Generate massive amounts of fake data

htmlify

Trait used to generate HTML from Rust structures

spin-contrib-http

Bunch of helpers for building HTTP services using Fermyon Spin

obeli-sk-wasm-workers

Internal package of obeli-sk

webpixels

Libmosh for WebAssembly

wings

WASM plugin system for Geese

sapp-wasm

Part of miniquad rendering library. Binding and JS implementation of GL and sokol-app API.

wasmtime-c-api-impl

C API to expose the Wasmtime runtime

pax-engine

Root import entry-point for using Pax in a Rust program

substreams-cosmos

Substreams development kit for Cosmos chains, contains Firehose Block model and helpers

msal_browser

Rust WASM wrapper for msal-browser.js

tortuga

A Rust-based CGI-specific HTTP web server

workflow-serializer

Serialization framework for wrapping Borsh-serialized payloads

http-wasm-guest

providing a http-wasm guest handler

unc-sys

Syscall definitions for builtin functions of the utility runtime

sortable-js

bindings to SortableJS, to build sortable lists in wasm

dusk-stake-contract-dd

Data driver for Dusk Stake Contract

jintemplify

A CLI tool to compose files using Jinja2(Rust Tera) templates and YAML variables

leptos_workers

WebWorker library for the Leptos web framework

wit-bindgen

Rust bindings generator and runtime support for WIT and the component model. Used when compiling Rust programs to the component model

ux-components

Backend agnostic GUI framework

wasmedge-wasi-nn

High-level Rust bindings for wasi-nn, with LLM extensions

wasm_evt_listener

A smart Future-based WASM event listener that cleans up after itself on drop

obsidian-lib

reading and extracting files from Obsidian .obby plugin files

cgn

optimally compressing chess games in PGN format

web-sys-stream-utils

Stream-related utilities for web-sys

wasi-vfs

A virtual filesystem layer for WASI

war3parser

A extractor and parser for Warcraft 3 map files

rs_web_component

create a custom element for a web project

pconvert-rust

Rust version of P(NG)Convert, a simple PNG conversion tool

tauri-wasm

The tauri framework library for pure rust frontend

wasm-coredump-types

Wasm coredump shared types

yew-notifications

Toaster components library for Yew

js_ffi

A FFI library for calling javascript

dportable

Portable interface for various utilities

rune-wasm

A WASM module for the Rune Language, an embeddable dynamic programming language for Rust

suika_wasm

A middleware for the suika web stack to serve pre-compiled WebAssembly (Wasm) files

natrix-cli

Natrix CLI tool

bevy_rtc

A client-server library designed over WebRTC for Bevy

deli

ergonomic way to define data models that are seamlessly converted into IndexedDB object stores, utilizing derive macros

web-image

easy interop between web APIs and DynamicImage from image-rs

nyar-wasm

High level wasm builder

web_panic_report

A panic hook which replaces an HTML element with a bug report form

rooting

Associate data with HTML elements in WASM

wasmer-runtime-near

Wasmer runtime library

crows-coordinator

Coordinator server for Crows

wat_formatter

WebAssembly Text Format formatter

web-rpc

Bi-directional RPC for the Web

traefik_wasm_api

wasm interface for traefik

extension_api

自定义wasm plugin 扩展api

nanoid-wasm

NanoId for wasm

notemine

a nostr note miner compiled to wasm

wasm_svg_graphics

rendering SVG Graphics with WASM

wasmi_cli

WebAssembly interpreter

golem-wit

WIT definitions and WASI adapter modules for Golem

neo-babylon

A wasm-bindgen-based wrapper for Babylon.js

nucleide

manipulate custom sections of a WebAssembly module to view/edit application metadata

refilelabs-image

Wasm-based image processing library developed by re;file labs

seed

framework for creating web apps, using WebAssembly

liblzma-sys

Raw bindings to liblzma which contains an implementation of LZMA and xz stream encoding/decoding. High level Rust bindings are available in the liblzma crate

wasmprof

allows to profile code running inside of wasmtime

perspective-js

A data visualization and analytics component, especially well-suited for large and/or streaming datasets

ambient_shared_types

Types shared between the host and the guest of the Ambient runtime

mrml-wasm

Wasm wrapping on MRML

terrazzo-terminal

web-based terminal emulator built on Terrazzo

smlibrbase

SmartModule Base Library for Wasm

cross_usb

USB library which works seamlessly across both native and WASM targets

opslang-wasm

A command and control system for C2A-based satellites

witgen

help you generate wit definitions in a wit file for WebAssembly

dorothy-ssr

The lib for building Dorothy SSR games in Rust running on target wasm32-wasi

wazzup

Very opinionated Rust WASM project builder

geo-nd-wasm

A WASM interface to the geo-nd library

wiwi-wasm

Nicer, higher level APIs for working with JavaScript from Rust (WASM), mostly revolving around builder-style APIs

streaming-http-range-client

A client for ergonomically streaming HTTP Range requests

rsstv

A SSTV transcoder written in Rust. Currently supporting just the Martin M1 mode

scale-core

low level datastructures and functionality for compiling for SCALE via wasm

browser-fs

A browser-based filesystem implementation for WebAssembly applications

logic-mesh

Control logic engine using event based and reactive blocks written in Rust

sycamore-web

proc-macro crate for Sycamore

leptos-bevy-canvas

Embed an idiomatic Bevy app inside your Leptos app with ease

mechtron

Part of http://thecosmicinitiative.io This package--MECHTRON--provides an API and framework that allows a Wasm component to send and receive messages from other Wasm components

hotg-rune-core

Core abstractions and types used across the Rune platform

typescript-definitions

serde support for exporting Typescript definitions

rotext_wasm_bindings

WASM bindings for rust crate rotext

cpclib-wasm

webasm tools for cpclib

yew-chart

components that can be assembled to form a chart

spawn64

An efficient way to spawn futures in WASM

async-tar-wasm

async TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…

object-store-wasm

WebAssembly object_store implementation