Lib.rs

getrandom

A small cross-platform library for retrieving random data from system source

wasm-bindgen

Easy support for interacting between JS and Rust

wasm-encoder

A low-level WebAssembly encoder

wasmtime

High-level API to expose the Wasmtime runtime

jsonrpsee

JSON-RPC client/server framework

wasi

WASI API bindings for Rust

wit-component

Tooling for working with *.wit and component files together

wit-bindgen

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

console_error_panic_hook

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

wasmtime-cranelift

Integration between Cranelift and Wasmtime

ts-rs

generate typescript bindings from rust types

wasmi

WebAssembly interpreter

tsify

generating TypeScript definitions from rust code

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

wasmprinter

Rust converter from the WebAssembly binary format to the text format

wasmtime-asm-macros

Macros for defining asm functions in Wasmtime

wasm-bindgen-rayon

Adapter for using Rayon-based concurrency on the Web

web-time

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

wasm-smith

A WebAssembly test case generator

gloo

A modular toolkit for Rust and WebAssembly

tonic-web-wasm-client

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

v_frame

Video Frame data structures, originally part of rav1e

wasmtime-cache

Support for automatic module caching with Wasmtime

trunk

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

wasix

API bindings for Rust

n0-future

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

obelisk

Deterministic workflow engine

indexed_db_futures

Future bindings for IndexedDB via web_sys

wasmtimer

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

wasmparser

event-driven library for parsing WebAssembly binary files

walrus

performing WebAssembly transformations

wit-bindgen-cli

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

wasm-pkg-common

Wasm Package common types and configuration

pulley-interpreter

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

wasmtime-provider

A wasmtime engine provider for the waPC host

vertigo

Reactive Real-DOM library with SSR for Rust

wstd

An async standard library for Wasm Components and WASI 0.2

wasm-streams

Bridging between web streams and Rust streams using WebAssembly

sprintf

Clone of C s(n)printf in Rust

kiteconnect-async-wasm

Modern async Rust client for KiteConnect REST APIs with WASM support. Clean, well-documented, and focused on REST-only operations.

wrpc-transport

wRPC core transport functionality

screeps-game-api

WASM bindings to the in-game Screeps API

proxy-wasm

WebAssembly for Proxies

sqlite-wasm-rs

wasm32-unknown-unknown bindings to the libsqlite3 library

deno_graph

Module graph analysis for deno

boa_gc

Garbage collector for the Boa JavaScript engine

adana-db

namespaces aliases for command lines & basic scripting language

greentic-interfaces

Greentic ABI: WIT contracts, generated bindings, thin mappers

hyperlight-wasm

that enables wasm modules and components to be run inside lightweight Virtual Machine backed Sandbox. It is built on top of Hyperlight.

wash-cli

wasmCloud Shell (wash) CLI tool

rln

APIs to manage, compute and verify zkSNARK proofs and RLN primitives

gloo-timers

Convenience crate for working with JavaScript timers

fluvio-smartmodule

Used by Fluvio SmartModule

witx-codegen

WITX code generator for WebAssembly guest modules

wasm-tools

CLI tools for interoperating with WebAssembly files

macerator

Type and target-generic SIMD

wasm-timer

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

wasm-opt

bindings

extism-pdk

Extism Plug-in Development Kit (PDK) for Rust

webui

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

virtual-fs

Wasmer Virtual FileSystem

domainstack

Write validation once, use everywhere: Rust rules auto-generate JSON Schema + OpenAPI + TypeScript/Zod. WASM browser validation. Axum/Actix/Rocket adapters.

ratzilla

Build terminal-themed web applications with Ratatui and WebAssembly

rsxtk

A high-performance Rust WASM Toolkit for managing and running WASI scripts, WAT, and WASM modules

yew

A framework for creating reliable and efficient web applications

capsule-run

Secure WASM runtime to isolate and manage AI agent tasks

jsonrpsee-ws-client

JSON-RPC websocket client

graphql-wrapping-types

Compact representation for GraphQL list and required wrapping types

kubewarden-policy-sdk

Kubewarden Policy SDK for the Rust language

wasmcloud-test-util

testing wasmCloud hosts, providers, and components

warpgate

Download, resolve, and manage Extism WASM plugins

exocore

Distributed applications framework

sycamore

building reactive web apps in Rust and WebAssembly

aframe

High-level Aframe VR bindings for Rust WASM

leptos_server

RPC for the Leptos web framework

wasmer-types

Wasmer Common Types

wit-bindgen-core

Low-level support for bindings generation based on WIT files for use with wit-bindgen-cli and other languages

mik-sdk

Ergonomic macros for WASI HTTP handlers - ok!, error!, json!

finite-wasm

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

golem-wasm-rpc

Golem WASM RPC support library

wasm-server-runner

cargo run for wasm programs

jugar-probar

Probar: Rust-native testing framework for WASM games

wain

WebAssembly interpreter written in Safe Rust with zero dependencies

lbc

A Leptos component library based on the Bulma CSS framework

leptos-state

A powerful state management library for Leptos applications with state machines, persistence, and DevTools

reconnecting-jsonrpsee-ws-client

jsonrpc-ws-client that reconnects automatically. Warning: It may lose subscription messages when reconnecting.

makepad-studio

Makepad studio

ferrous-actions

GitHub actions for Rust written in Rust and compiled to WebAssembly

fastly

Compute API

gents

generate Typescript interfaces from Rust code

debuginfo-split

Splits out the debugging informations

spintronics

Pure Rust library for simulating spin dynamics, spin current generation, and conversion phenomena in magnetic and topological materials

emom

A customizable EMOM (Every Minute On the Minute) timer for workouts, with a drift-correcting countdown timer library for WebAssembly applications

shopify_function_provider

Provider for the Shopify Function Wasm API

beamterm-renderer

High-performance WebGL2 terminal renderer for beamterm, targeting sub-millisecond render times in web browsers

wasm_thread

An std thread replacement for wasm32 target

katex-rs

KaTeX - Fast math typesetting for anywhere, more than just the web

jsbind

Bindings for basic JS types required for webbind

swc_emotion

AST Transforms for emotion

wit-encoder

A WIT encoder for Rust

h2lang

H2 Language - A Herbert Online Judge compatible programming language with multi-agent support

greentic-telemetry

Thin telemetry facade for Greentic: tracing/logging/metrics with OTLP + WASM

greentic-component

High-level component loader and store for Greentic components

leaflet

A wasm-bindgen wrapper for Leaflet.js

fp-bindgen

Bindings generator for full-stack WASM plugins

devcycle-bucketing-rs

DevCycle Bucketing Library in Rust

ankurah

Observable, event-driven state management for native and web

extism-manifest

Extism plug-in manifest crate

wasm_runtime_layer

Compatibility interface for WASM runtimes

wasm-rquickjs-cli

wrapping JavaScript modules as WebAssembly components using the QuickJS engine

medea-jason

Client library for Medea media server

wasm-component-ld

Linker for wasm32-wasip2

dwind

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

themed-styler

Client-side runtime styling engine for web and Android/iOS Native with theme support and Tailwind subset

waspy

A Python interpreter written in Rust, designed for WebAssembly

send_cells

Safe and unsafe cells implementing Send/Sync

percy-dom

A standalone Virtual DOM creation, diffing and patching implementation

rphtml

A html parser written in rust

rust-music-theory

that procedurally implements music theory notions like Scale, Chord, Interval, Note

ruvector-sona

Self-Optimizing Neural Architecture - Runtime-adaptive learning for LLM routers with two-tier LoRA, EWC++, and ReasoningBank

shared-container

A unified abstraction for shared data access in both multi-threaded and single-threaded environments

turbomcp-wasm

WebAssembly bindings for TurboMCP - MCP client for browsers and WASI environments

yield-progress

Combined progress reporting and cooperative task yielding

starlane

– An Orchestration and Infrastructure Framework for WebAssembly Components (https://starlane.io) This packaged manages HyperSpace which provides infrastructure for Space Apis…

piet-web

Web canvas backend for Piet 2D graphics abstraction

styled

Scoped styles for your Leptos components

mdbook-repl

based mdbook preprocessor that allows you to execute code in your mdbook without any server. Python, Typescript, Javascript etc.

mapboxgl

Unofficial Rust binding for mapbox-gl-js

cjseq

Create+process+modify+convert CityJSONSeq

jsonrpsee-client-transport

JSON-RPC client transports

pulumi_gestalt_proto

Generated Pulumi Protobuf bindings for Pulumi Gestalt

ft-sdk

SDK for building FifthTry Applications

watt

Runtime for executing Rust procedural macros compiled as WebAssembly

ftl-cli

CLI wrapper for Spin to build and deploy MCP tools using ftl-mcp framework

synckit-core

High-performance sync engine for local-first applications

wasmi_cli

WebAssembly interpreter

pyfalcon

A cross-version Python disassembler that supports both command-line and web

minwebgl

Minimal WebGL toolkit for concise graphics programming with utilities, shaders, and resource management

sorex

Formally verified full-text search with suffix arrays

wapc

An engine-pluggable WebAssembly Host Runtime implementing the waPC protocol

feature-extension-for-wasm-bindgen-futures

Feature extension for wasm-bindgen-futures

harper-pos-utils

The language checker for developers

arrow-udf

User-defined function framework for arrow-rs

gtfs-guru

Command-line interface for GTFS Guru validator

containerd-shim-wasm

building containerd shims for wasm

cardinal-wasm-plugins

Host runtime for Cardinal's WebAssembly middleware

typed-ski

SKI calculus evaluator in Rust compiled to WASM

probar-js-gen

NASA/DO-178B-grade Rust DSL for type-safe JavaScript generation

deterministic-wasi-ctx

A wasmtime-wasi WasiCtx implementation that is fully deterministic

trustee

A general-purpose agent that can morph into different specialized agents using WASM lifecycle plugins

yew-nav-link

Navigation link component for Yew with automatic active state detection

fluvio-stream-model

Fluvio Event Stream Model

wgpu-3dgs-viewer

A 3D Gaussian splatting viewing library written in Rust using wgpu

wadm

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

terrazzo

build dynamic web pages in Rust

mathlikeanim-rs

creating mathematical animations

struct-llm

Lightweight, WASM-compatible library for structured LLM outputs using tool-based approach

wasm_split_helpers

Split a WASM module into lazily loadable chunks

fontspector-profile-opentype

Fontspector checks for OpenType font specification compliance

longcipher-leptos-components

Production-ready UI components for Leptos applications

wasmtime-fiber

Fiber support for Wasmtime

async-timer

Timers for Rust async story

clg

A logger specifically designed for wasm32-unknown-unknown

benchmark-simple

A tiny, super simple and portable benchmarking library

js

Call JavaScript from WebAssembly

indxdb

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

wascan

Production-ready barcode and QR code scanner for web browsers. Handles camera access, streaming, and file input automatically.

ruwren

bindings to Wren programming language

rexie

futures based wrapper around IndexedDB that compiles to webassembly

deno_cache_dir

Cache directory logic used in Deno

openapi-client-gen

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

hang-wasm

Web implementation for MoQ utilizing WebAssembly+Typescript

gloo-net

HTTP requests library for WASM Apps

shapdf

Create Shapes into PDF

ankurah-virtual-scroll

Platform-agnostic virtual scroll state machine with pagination for Ankurah

wasmtime-component-util

types and functions to support the component model in Wasmtime

wasmer-compiler

Base compiler abstraction for Wasmer WebAssembly runtime

slices-lexicon

AT Protocol lexicon validation library for Slices

frontwork

The TypeScript Framework using Deno & Webassembly

pjson-rs-domain

Pure domain logic for PJS - WASM-compatible core

panchangam

High-precision Vedic Panchangam calculations using Swiss Ephemeris

webbind

Rust bindings for the web api, auto-generated from WebIDL

sledgehammer_bindgen

Fast batched js bindings

pax-message

Shared message structs used by Pax runtimes

caxton

A secure WebAssembly runtime for multi-agent systems

stak-wasm

Stak Scheme in WebAssembly

quant-opts

High-performance Rust library for option pricing and risk

valrs

Standard Schema specification

matrix_indexed_db_futures

A fork of indexed_db_futures — Future bindings for IndexedDB via web_sys

fluvio-stream-dispatcher

Fluvio Event Stream access

serve-wasm

lightweight HTTP server for serving WebAssembly applications with the correct security headers

mqtt5-wasm

MQTT v5.0 WebAssembly client and broker for browser environments

proto_pdk_test_utils

testing proto WASM plugins

relay-hook-transpiler

Minimal JSX/TSX transpiler for Relay hooks with dynamic import() rewrite to context.helpers.loadModule and friendly errors

pylate-rs

WebAssembly library for late interaction models

shlesha

High-performance extensible transliteration library with hub-and-spoke architecture

wasmgdb

gdb for WebAssembly

perseus

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

torigen_mounter

Core functionality for Torigen, a tool for mounting and managing Tor hidden services

stylist

CSS-in-Rust styling solution for WebAssembly Applications

xlsx-handlebars

processing XLSX files with Handlebars templates, supporting WASM, Node.js, Deno, and browsers

ruvector-math-wasm

WebAssembly bindings for ruvector-math: Optimal Transport, Information Geometry, Product Manifolds

leptos-bevy-canvas

Embed an idiomatic Bevy app inside your Leptos app with ease

ory-kratos-client-wasm

A fork of ory-kratos-client that uses the browser's Fetch API instead of reqwest when building for wasm

shopify_function_wasm_api

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

wasm-bindgen-spawn

Web Worker Multithreading library for wasm-bindgen the uses shared memory

tylax

High-performance bidirectional LaTeX ↔ Typst converter

cargo-run-wasm

Trivially run wasm applications and examples in the browser

web-fs

An async file system for browser wasm

kobold

Easy declarative web interfaces

wasm-wave

WebAssembly Value Encoding

maia-wasm

Maia SDR WASM frontend

unicode-shaper

Shape unicode text so that renderers like WebGL and WebGPU can properly display the glyphs

freenet-stdlib

Freeenet standard library

linera-kywasmtime

Time utils for WASM (Linera fork)

cross_usb

USB library which works seamlessly across both native and WASM targets

selium-switchboard-protocol

Selium module for abstracting channel management and messaging patterns

obeli-sk-grpc

Internal package of obeli-sk

press_rs

Tiny file compressor and packager on Rust

makepad-live-id

Makepad live id symbol interning

yew-lucide

Yew components for Lucide icons

fastedge

SDK that helps you to create edge cloud application using WASM

rose-wasm

WASM bindings for Rose wallet

metrum

Easily work with and compare temeratures in different units

witx-indent

Indent WITX files (WebAssembly)

custom-element

A CustomElement trait for implementing custom elements (web components) in Rust

ruvector-router-wasm

WASM bindings for ruvector-router-core

wasm-pack-test-all

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

mlua-wasmer

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

mrubyedge-cli

mruby/edge cli endpoint - run, compile to wasm, etc

lemmy-client

HTTP client for Lemmy

minilamb

A minimal lambda calculus library in Rust

koru-lambda-core

A minimal axiomatic system for distributed computation

wasmhub

Download and manage WebAssembly runtimes for multiple languages

graph_generation_language

Core library for the Graph Generation Language (GGL)

nsm-nitro-enclave-utils

simplifies development for AWS Nitro Enclaves by enabling the reading and verifying of mocked attestation documents while in local development environments. Once your ready to go to production…

tja

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

homeskillet_boris

Anchored orchestration layer for operationTorque with Covenant/Fusion/Strike patterns for parallel pipeline execution

stork-search

Impossibly fast web search, made for static sites

zaw

Zero-allocation WebAssembly communication protocol for Rust

ffmpeg-wasi

FFMPEG for WebAssembly/WASI

iris-wasm

WASM bindings for Iris wallet

browser_log

Advanced logging and panic handling for WebAssembly applications with browser console integration

wasm_dep_analyzer

Wasm module dependency analysis for module resolution

leptos_form_tool

A declarative way to create forms for leptos

wasm3

Rust bindings for wasm3

nam-wasmer

High-performance WebAssembly runtime

telemetrydeck-wasm

(unofficial) TelemetryDeck client for fast and reliable libraries and apps using Rust and WebAssembly

wasm-bindgen-futures

Bridging the gap between Rust Futures and JavaScript Promises

cardinal-uxn

Uxn CPU interpreter

rs_web_component

create a custom element for a web project

tiptap-rs

Wasm bindings for Tiptap

acadlisp

AutoLISP interpreter and mini CAD engine - CSV/TPL/LSP workflow emulator for AutoCAD 9/10 (DOS era)

lcax

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

momenta-dom

DOM rendering extensions for Momenta framework

distance-wasm

WebAssembly bindings for high-performance string distance and similarity algorithms

minify-html-common

Common code and data for minify-html*

externref

Low-cost reference type shims for WASM modules

oracle_omen_plan

Planning DSL and DAG compiler for oracle.omen

fob-graph

Fob graph - Pure graph data structures for module dependency graphs

kcr_extensions_istio_io

Kubernetes Custom Resource Bindings

ansi2

js-utils

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

wasm-sandbox

A secure WebAssembly sandbox with dead-simple ease of use, progressive complexity APIs, and comprehensive safety controls

spair

A framework for single-page application in Rust

seven-layer-symphony

Death of code, birth of music. Time-weaving consciousness system where intent manifests reality through 7-dimensional resonance at 432Hz

adana-script-wasm

namespaces aliases for command lines & basic scripting language

puccini-tosca

TOSCA parser, validator, and Floria compiler

wasm-slim

WASM bundle size optimizer

json_to_prolog

convert JSON to Prolog

mvt-reader

decoding and reading mapbox vector tiles in Rust and WebAssembly

std-mumu

Standard input/output tools for MuMu/Lava

js-sys-x

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

cargo-udonsharp

Cargo subcommand for UdonSharp compilation

skillz

Self-extending MCP server - build and execute custom AI tools at runtime

sortable-js

bindings to SortableJS, to build sortable lists in wasm

rscel

Cel interpreter in rust

ywasm

High performance implementation of the Yjs CRDT

prophecy

FutureSDR GUI

ts-rs-forge

Generate TypeScript bindings from Rust types (Namastex fork with use_ts_enum)

zellij-server

The server-side library for Zellij

binmod

runtime for Binmod WebAssembly modules

wasmer-interface-types-fl

WebAssembly Interface Types library for Wasmer

pulumi_gestalt_rust_adapter_wasm

Wasm Rust adapter for Pulumi Gestalt

json-from-wast

Conversion from *.wast files to JSON

blots-wasm

WebAssembly bindings for Blots, a small, simple, expression-oriented programming language

web-codecs

WASM bindings for Web Codecs

wasvy

Bevy WASM

terrazzo-terminal

web-based terminal emulator built on Terrazzo

enarx

Tools for deploying WebAssembly into Enarx Keeps

powersync_sqlite_nostd

Lightweight, semi-unsafe, nostd bindings to sqlite3

http_req_wasi

HTTP client for the WasmEdge network socket API. Derived from the http_req library.

xwt-wtransport

xwt that runs natively via wtransport crate

leptos-md

signal-free Markdown renderer for Leptos with Tailwind CSS styling

pico-detect

Pixel Intensity Comparison-based Object (PICO) detection library

cosmic-space

the Space portion of starlane as opposed to hyperspace

leptos-shadcn-signal-management

Signal lifecycle management utilities for Leptos 0.8.8+ with tailwind-rs integration

witmproxy

A WASM-in-the-middle proxy

wasmbin

A self-generating WebAssembly parser and serializer

relib_interface

relib is a framework for reloadable dynamic libraries

wasi-nn

High-level Rust bindings for wasi-nn

wat_syntax

WebAssembly Text Format syntaxes

dwbase-core

DWBase: agent-first immutable atom store, components, and tools

mockforge-plugin-sdk

Official SDK for developing MockForge plugins with helper macros and testing utilities

clock-timer

A clock crate that offer a timer and a stopwatch to use in your apps

js-helpers

Easy interop utils for js objects in wasm

streamdal-gjson

Get (and set) JSON values quickly

monistode-emulator-bindings

Web assembly bindings for the monistode emulator

custom-print

Define custom println and dbg macros in wasm and other targets

async-utility

Collection of async utilities

spin-contrib-http

Bunch of helpers for building HTTP services using Fermyon Spin

wasmrun

A WebAssembly Runtime

edgebert

Fast local text embeddings library for Rust and WASM for BERT inference on native and edge devices with no dependencies

inferlet

support library for Pie

harper-literate-haskell

The language checker for developers

spow

Proof of Work for the Server and Client + WASM

wsc-attestation

Transformation attestation types for WebAssembly toolchains

beamterm-atlas

Font atlas generator for beamterm WebGL terminal renderer, creating GPU-optimized texture arrays from TTF/OTF fonts

vertigo-forms

Building block for forms in vertigo

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

stateroom-wasm

A macro for building a Stateroom service as a WebAssembly module

webglue

OpenGL ES 3.0 / WebGL2 wrapper for Rust and WebAssembly

jsonlogic-rs

jsonlogic (jsonlogic.com) implemented in Rust

flash-fuzzy-core

High-performance fuzzy search using Bitap algorithm with bloom filter pre-filtering. Zero dependencies, no_std compatible.

wasm-react

WASM bindings for React

webusb-web

WebUSB on the web 🕸️ — Access USB devices from the web browser

greentic-runner

Greentic runner binaries and re-exported host/new-runner APIs

ruchy-notebook

Interactive notebook runtime for Ruchy programming language

pax-engine

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

morsewave

High-performance Morse code encoder/decoder with WebAssembly support and Web Audio API playback

ftl-sdk

Thin SDK providing MCP protocol types for FTL tool development

moon_pdk_api

Core APIs for creating moon WASM plugins

pdk-proxy-wasm-stub

Due to a linker error in Windows (https://github.com/rust-lang/rust/issues/86125) that fails when importing a crate that has external symbols, even when they are not being used, we need a proxy-wasm-stub for non…

oxirs-wasm

WebAssembly bindings for OxiRS - Run RDF/SPARQL in the browser

wrpc-interface-http

wRPC HTTP interface

wasm-metadata

Read and manipulate WebAssembly metadata

wars

Wasm to Rust converter

pyodide-webassembly-runtime-layer

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

wasmcv

Rust bindings for wasmCV computer vision interfaces based on WebAssembly

godfather

Admin server for the Ordinary Framework

stunt

A declarative web framework for Rust/Wasm

trailbase-qs

Query string parser for TrailBase

exfiltrate_proxy

Proxy application for the exfiltrate crate

pelliote-editor-core

A fast, private email editor library core built with Rust and compiled to WebAssembly

trek-rs

A web content extraction library that removes clutter from web pages

artwrap

Minimal asynchronous smol/wasm wrapper for unified accessing selected primitives

weval

The WebAssembly partial evaluator

selium-runtime

Streaming compute fabric

posemesh-utils

functions and helpers for async operations, retries, and timeouts, supporting both native and WebAssembly targets

leptos-forms-rs

🚀 Type-safe, reactive form handling library for Leptos applications. Production-ready with 100% test success rate, cross-browser compatibility, and comprehensive validation. Built with Rust/WASM for high performance.

sublinear

High-performance sublinear-time solver for asymmetric diagonally dominant systems

rusty_spine

Spine runtime for Rust (and wasm!) transpiled from the official C Runtime

zu

Yew web components, implementing Material Design

small_string

7-byte small string optimisation for use in Nova JavaScript engine

css2xr

A lightweight, pure Rust HTML/CSS layout engine for WebXR (Flexbox, Grid, Animation)

monkey-wasm

monkey lang parser wasm version

foodshare-geo

High-performance geospatial utilities for distance calculations and PostGIS parsing

emscripten-val

wrapper around the emscripten/val api

theater

A WebAssembly actor system for AI agents

wasm-compose

composing WebAssembly components

wasm-pkg-core

Wasm Package Tools core libraries for wkg

natrix

Rust-First frontend framework

maplibre-gl-js

Unofficial MapLibre GL JS Rust bindings

wasi-preview1-component-adapter-provider

Embedded wasi-preview1-component-adapter binaries

bomboni_common

Common things for Bomboni library

swisseph-wasm

Swiss Ephemeris Bindings for WebAssembly

ianaio

backend frontend written in Rust Web Assembly RustWasm TS website

twors

2D game engine based on canvas and WASM

base_sequence_compression

compressing and decompressing DNA sequences

wasmi-validation

Wasm code validator

wasm_demo

Basic wasm demo to test and create full stak rust codes

wat_service

WebAssembly Text Format language service

portalis-core

Core library for the Portalis Python to Rust/WASM transpiler

aimo-note-agent

AIMO note app agent built with Amico

wasmtime-internal-winch

INTERNAL: Integration between Wasmtime and Winch

valrs-json

JSON Schema generation for Standard Schema

nam-wasmer-emscripten

Emscripten implementation library for Wasmer WebAssembly runtime

quill-wr

A thin Rust→WASM wrapper around the popular Quill.js rich text editor

wasmenv

version manager for wasm runtimes

dias

Minimal cross-platform support for common platform specific things, intended for small games for web plus desktopy platforms

wasmi-plugin-pdk

Plugin development kit for the wasmi WebAssembly Interpreter

mrml-wasm

Wasm wrapping on MRML

esox_wasm

WASM glue library for NISECI and HFBI calc

pi_share

rc, arc, lock, atomic

klyx_extension_api

A Rust-based API for building WebAssembly extensions for the Klyx

rustyle-css

Transformative Pure Rust CSS-in-RS solution for Leptos 0.8.14 with design tokens, components, modern CSS features, and exceptional developer experience

reflexo-typst-shim

A compatibility layer for Typst release and mainline versions