Lib.rs

serde-wasm-bindgen

Native Serde adapter for wasm-bindgen

wasi

WASI API bindings for Rust

wasm-encoder

A low-level WebAssembly encoder

wat

Rust parser for the WebAssembly Text format, WAT

web-time

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

wasmtime

High-level API to expose the Wasmtime runtime

ts-rs

generate typescript bindings from rust types

wasmi

WebAssembly interpreter

wasm-bindgen

Easy support for interacting between JS and Rust

deno_graph

Module graph analysis for deno

wasmtime-asm-macros

Macros for defining asm functions in Wasmtime

ed25519-compact

A small, self-contained, wasm-friendly Ed25519 implementation

console_error_panic_hook

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

worker

SDK for writing Cloudflare Workers

extism

runtime and Rust SDK

wasmparser-nostd

event-driven library for parsing WebAssembly binary files

trunk

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

virtual-fs

Wasmer Virtual FileSystem

indexed_db_futures

Future bindings for IndexedDB via web_sys

wasm-timer

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

futures-timer

Timeouts for futures

tsify

generating TypeScript definitions from rust code

wit-encoder

A WIT encoder for Rust

wasmtimer

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

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

leptos_router

Router for the Leptos web framework

youki

A container runtime written in Rust

wadm

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

wain

WebAssembly interpreter written in Safe Rust with zero dependencies

wasmer

High-performance WebAssembly runtime

wasmtime-provider

A wasmtime engine provider for the waPC host

wasm_thread

An std thread replacement for wasm32 target

wasmtime-component-util

types and functions to support the component model in Wasmtime

tsify-next

generating TypeScript definitions from rust code

tokio_with_wasm

Mimicking tokio functionalities on web browsers

wasm-opt

bindings

wasm-pkg-common

Wasm Package common types and configuration

wit-component

Tooling for working with *.wit and component files together

viceroy

local testing daemon for Fastly Compute

adblock

Native Rust module for Adblock Plus syntax (e.g. EasyList, EasyPrivacy) filter parsing and matching.

frontwork

The TypeScript Framework using Deno & Webassembly

deno_cache_dir

Cache directory logic used in Deno

crux_http

HTTP capability for use with crux_core

witx-codegen

WITX code generator for WebAssembly guest modules

linera-wasmer

High-performance WebAssembly runtime

detect-wasi

Detect if WASI can be run

pax-message

Shared message structs used by Pax runtimes

wasm-bindgen-rayon

Adapter for using Rayon-based concurrency on the Web

open-vector-tile

reads/writes The Open Vector Tiles 1.0 Specification

warpgate

Download, resolve, and manage Extism WASM plugins

roctogen

Github API and models generated from the official swagger OpenAPI specification

vertigo

Reactive Real-DOM library with SSR for Rust

mathlab

A Powerful Math Library for Rust

indexed-db

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

tracing-web

A tracing compatible subscriber layer for web platforms

topiary-tree-sitter-facade

Topiary’s uniform interface for tree-sitter (rust) and web-tree-sitter (wasm-bindgen)

wasm-streams

Bridging between web streams and Rust streams using WebAssembly

openapi-client-gen

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

webui

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

wasmprinter

Rust converter from the WebAssembly binary format to the text format

wapc

An engine-pluggable WebAssembly Host Runtime implementing the waPC protocol

obelisk

Deterministic workflow engine

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

rustpython-compiler

A usability wrapper around rustpython-parser and rustpython-compiler-core

superboring

A reimplementation of the 'boring' crate in pure Rust

edgee

The full-stack edge platform for your edge oriented applications

jsonrpsee-ws-client

JSON-RPC websocket client

watt

Runtime for executing Rust procedural macros compiled as WebAssembly

tailwind_fuse

Tailwind Merge and Variants

arrow-udf

User-defined function framework for arrow-rs

ratzilla

Build terminal-themed web applications with Ratatui and WebAssembly

respo

a tiny virtual DOM library migrated from ClojureScript

lazy-js-bundle

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

sqlite-wasm-rs

Provide sqlite solution for wasm32-unknown-unknown target

wadm-client

A client library for interacting with the wadm API

wasm_runtime_layer

Compatibility interface for WASM runtimes

chart-js-rs

Chart JS API for Rust WebAssembly

kubewarden-policy-sdk

Kubewarden Policy SDK for the Rust language

idb

A futures based crate for interacting with IndexedDB on browsers using webassembly

aframe

High-level Aframe VR bindings for Rust WASM

wasmcloud-test-util

testing wasmCloud hosts, providers, and components

sframe

pure rust implementation of SFrame (RFC 9605)

jsonlogic-rs

jsonlogic (jsonlogic.com) implemented in Rust

sprintf

Clone of C s(n)printf in Rust

yewdux

Ergonomic state management for Yew applications

gloo

A modular toolkit for Rust and WebAssembly

extism-manifest

Extism plug-in manifest crate

stak-wasm

Stak Scheme in WebAssembly

exocore

Distributed applications framework

connection-string

Connection string parsing in Rust (and WebAssembly)

gear-wasm-optimizer

optimizing Gear programs

fp-bindgen

Bindings generator for full-stack WASM plugins

wasm-pack

📦✨ your favorite rust -> wasm workflow tool!

workflow-terminal

Terminal abstraction layer over Xterm.js and termion crates for creating terminal applications that function uniformly in native (console) and in browser (WASM32) environments

opa-wasm

OPA policies compiled to WASM

wasmgdb

gdb for WebAssembly

webc

WebContainer implementation for wapm.io

sycamore

building reactive web apps in Rust and WebAssembly

containerd-shim-wasm

building containerd shims for wasm

dioxus-charts

Chart components library for Dioxus

turf

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

lunk

Event graph processing

leaflet

A wasm-bindgen wrapper for Leaflet.js

phomo

A photo mosaic generation library

benchmark-simple

A tiny, super simple and portable benchmarking library

cargo-run-wasm

Trivially run wasm applications and examples in the browser

cargo-component-core

The core library for cargo-component

percy-router

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

wat_server

WebAssembly Text Format language server

cargo-screeps

Build tool for deploying Rust WASM code to Screeps game servers

wonnx

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

wit-bindgen-cli

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

wasm-server-runner

cargo run for wasm programs

mitex-glob

Glob impl for MiTeX

wasmi-validation

Wasm code validator

graphql_client_codegen

graphql_client

dprint-plugin-json

JSON formatter for dprint

zuicon-material

Wrapper of material design icons for yew framework

tracing-wasm

tracing subscriber for browser WASM

fluvio-types

Fluvio common types and objects

moq-web

Web implementation for MoQ utilizing WebAssembly+Typescript

js

Call JavaScript from WebAssembly

zduny-wasm-timer

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

wasmer-sys-utils

Wasmer utilities for a sys environment

workflow-serializer

Serialization framework for wrapping Borsh-serialized payloads

wrpc-transport-nats

wRPC NATS transport

arcjet-gravity

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

my-ecs

An Entity Component System (ECS) library

leptos_reactive

Reactive system for the Leptos web framework

async-timer

Timers for Rust async story

sledgehammer_bindgen

Fast batched js bindings

dioxus-web-component

Expose a Dioxus component as a Web Component

apexcharts-rs

Rust WASM bindings and chart components for ApexCharts

war3parser-cli

A extractor and parser for Warcraft 3 map files

macerator

Type and target-generic SIMD

wasi-nn

High-level Rust bindings for wasi-nn

starlane

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

clg

A logger specifically designed for wasm32-unknown-unknown

wasm-pkg-core

Wasm Package Tools core libraries for wkg

linera-wasmer-compiler-singlepass

Singlepass compiler for Wasmer WebAssembly runtime

mapboxgl

Unofficial Rust binding for mapbox-gl-js

dwind

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

wasmtime-cranelift-shared

Base-level integration with Wasmtime and Cranelift

wasm_component_layer

WebAssembly component model implementation for any backend

ozz-animation-rs

runtime library for ozz-animation with cross-platform deterministic

perseus

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

warg-credentials

manage the keyring for the Warg client

medea-jason

Client library for Medea media server

walc_model

Interpreter for Walc programming language

relib_internal_crate_compilation_info

relib is a framework for reloadable dynamic libraries

mvt-reader

decoding and reading mapbox vector tiles in Rust and WebAssembly

bulwark-cli

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

fastn-jdebug

fastn: Full-stack Web Development Made Easy

deterministic-wasi-ctx

A wasi-common WasiCtx implementation that is fully deterministic

async-utility

Collection of async utilities

warpgate_api

APIs for working with Warpgate plugins

wasmcloud-secrets-types

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

redpanda-transform-sdk-varint

Varint decoding for redpanda-transform-sdk

mathlikeanim-rs

creating mathematical animations

linera-wasmer-compiler-cranelift

Cranelift compiler for Wasmer WebAssembly runtime

aws-fully-qualified-names

For extracting def use statements from code

wasmi_cli

WebAssembly interpreter

prest

Progressive RESTful framework

crux_kv

Key-Value capability for use with crux_core

wasco

A minimal wasm compiler backend

rush_core

The rules engine is based on the rete algorithm

wasm_bench

benchmarker for in browser wasm

obeli-sk

Deterministic workflow engine

mdbook-repl

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

n0-future

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

wasmedge-sdk

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

kobold

Easy declarative web interfaces

terrazzo

build dynamic web pages in Rust

pagurus

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

emscripten-functions

Rust-friendly bindings to various emscripten system functions

ywasm

High performance implementation of the Yjs CRDT

leptos_hotkeys

that declaratively pairs keybindings with callbacks for Leptos applications

pax-chassis-web

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

cliw

Command Line In Web

ruswacipher

encrypting and protecting WebAssembly modules

dominator

Zero-cost ultra-high-performance declarative DOM library using FRP signals

enfync

Environment-friendly async utilities

jsonrpsee-client-transport

JSON-RPC client transports

orca-wasm

A lightweight WebAssembly Transformation Library for the Component Model

xwt-wtransport

xwt that runs natively via wtransport crate

wasm-graph

WASM format graph representation

fluvio-smartmodule

Used by Fluvio SmartModule

workflow-d3

D3 visualization API bindings and utilities

stateroom-wasm

A macro for building a Stateroom service as a WebAssembly module

py-rs

generate python bindings from rust types

pyodide-webassembly-runtime-layer

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

proxy-wasm

WebAssembly for Proxies

wit-parser

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

maia-wasm

Maia SDR WASM frontend

workflow-store

File storage access crate abstracting file I/O and browser localstorage

monaco

Rust WASM bindings for the Monaco Editor

debuginfo-split

Splits out the debugging informations

chap

easy to learn, interpretive, scripting language written in Rust

activity-build

Build tool for Discord activities in Rust

stork-search

Impossibly fast web search, made for static sites

wasmworker

Dispatching tasks to a WebWorker without SharedArrayBuffers

mrubyedge

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

wacker-daemon

wacker daemon cli

trunkls

A language server for Trunk's custom HTML attributes

chromiumoxide_cdp

Contains all the generated types for chromiumoxide

tree-sitter-loader

Locates, builds, and loads tree-sitter grammars at runtime

wasmer-interface-types-fl

WebAssembly Interface Types library for Wasmer

dioxus-dx-wire-format

Wire format for the Dioxus CLI

rust-rectangle-dividing

A rectangle dividing algorithm written in Rust

finite-wasm

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

wasm_to_png

convert a wasm file to png

weval

The WebAssembly partial evaluator

indxdb

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

golem-wasm-ast

WASM AST

js-helpers

Easy interop utils for js objects in wasm

zellij-server

The server-side library for Zellij

cosmic-space

the Space portion of starlane as opposed to hyperspace

bomboni

Utility Library for Rust

wasm-pkg-client

Wasm package client

unc-vm-runner

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

gloo-timers

Convenience crate for working with JavaScript timers

perspective

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

stylist

CSS-in-Rust styling solution for WebAssembly Applications

ansi2

clique-sibyl-commonlib

Clique Sibyl Common Library, for generating and verifying TEE attestation (Intel SGX, Intel TDX) and providing customized TLS verification with TEE attestation

qdrant_rest_client

The Qdrant SDK for WebAssembly

wstd

An async standard library for Wasm Components and WASI 0.2

sbbf-rs

Split block bloom filter implementation

wasm-react

WASM bindings for React

leptos-bevy-canvas

Embed an idiomatic Bevy app inside your Leptos app with ease

wasmbin

A self-generating WebAssembly parser and serializer

swc_prefresh

AST Transforms for prefresh plugin

crux_platform

Platform capability for use with crux_core

ad-astra

Embeddable scripting language platform Ad Astra. Main Crate.

rexie

futures based wrapper around IndexedDB that compiles to webassembly

lemmy-client

HTTP client for Lemmy

hallomai

converter USFM<->USJ<->USX

sapp-wasm

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

pulley-interpreter

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

spow

Proof of Work for the Server and Client + WASM

reqwest-h3

hitdns fork of higher level HTTP client library

wasmedge_stable_diffusion

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

awsm_web

Wrappers for WASM

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

wasm-http-hyper

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

gloo-net

HTTP requests library for WASM Apps

supabase-js-rs

Rust bindings for Supabase JavaScript library via WebAssembly

wit-bindgen-moonbit

MoonBit bindings generator for WIT and the component model, typically used through the wit-bindgen-cli crate

earthbucks_blake3

Blake3 hash function for EarthBucks with optional support for WASM

wasm2usharp

converting WebAssembly to UdonSharp

linera-parity-wasm

WebAssembly low-level format library

uni-app

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

cross_usb

USB library which works seamlessly across both native and WASM targets

emscripten-val

wrapper around the emscripten/val api

marine-it-generator

Fluence Marine interface types generator

yew-notifications

Toaster components library for Yew

zinzen

Algorithm for auto-scheduling time-constrained tasks on a timeline

spair

A framework for single-page application in Rust

leptos_animated_for

<AnimatedFor /> component utilizing FLIP position transitions for Leptos

custom-print

Define custom println and dbg macros in wasm and other targets

claw-common

The Claw language common types and functions

externref

Low-cost reference type shims for WASM modules

rocal-cli

CLI tool for local-first-development driven web application framework

floating-ui-utils

Rust port of Floating UI. Utilities for Floating UI.

data-faking

Generate massive amounts of fake data

boytacean-common

Commons library for Boytacen

nanoid-wasm

NanoId for wasm

zuicon-ant

Wrapper of ant design icons for yew framework

rempl

creating html components directly in your source

msal_browser

Rust WASM wrapper for msal-browser.js

tortuga

A Rust-based CGI-specific HTTP web server

livid

lightweight frontend Rust crate for creating web apps via webassembly

monistode-emulator-bindings

Web assembly bindings for the monistode emulator

wasm-css

Ergonomic WASM CSS Framework

viceroy-lib

Viceroy implementation details

htmlify

Trait used to generate HTML from Rust structures

wrpc-interface-http

wRPC HTTP interface

flawless-wasabi

A WebAssembly ABI for flawless, inspired by io_uring

karaty-blueprint

Karaty template develop blueprint

wasmedge-wasi-nn

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

nano-id

A tiny, secure, URL-friendly, unique string ID generator for Rust

cargo-daku

Daku API cargo plugin

wat_formatter

WebAssembly Text Format formatter

wasm-wnfs

WebNative Filesystem API (WebAssembly)

trunk-ng

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

wasmdev

web development server library

yew-chart

components that can be assembled to form a chart

reflexo-vec2svg

Export a frame of Typst document into svg element

si-img

lightweight Rust library to generate Social Media Preview Images

jsonrpsee-server

JSON-RPC server that supports HTTP and WebSocket transports

mlua-wasmer

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

wasmcloud-interface-messaging

Interface library for the wasmCloud messaging capability, wasmcloud:messaging

fontkit

font loading and indexing

yewlish-attr-passer

A Yew component that passes custom attributes to its child

wasmcv

Rust bindings for wasmCV computer vision interfaces based on WebAssembly

abe_policy

Policy and attributes definition for ABE cryptosystems

suparust

Supabase client for Rust with support for WASM

zu

Yew web components, implementing Material Design

wiwi-wasm

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

hexchess

/ TypeScript library for Gliński's hexagonal chess, and the brain of hexchess.club

web-streams

WASM bindings for the Streams API

js_ffi

A FFI library for calling javascript

cosmic-nom

Is a collection of utilities for making using the great nom parser combinator easier to use

retrier

A wasm-compatible retry library for futures

otoroshi_rust_types

A CLI to create and build WASM binaries

wasm-wave

WebAssembly Value Encoding

wapc-guest

Guest SDK for building waPC-compliant WebAssembly Modules

webrtc-unreliable

UDP-like (unreliable, unordered) communication between Javascript/WebAssembly and native Rust via WebRTC

rsstv

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

leptos_server

RPC for the Leptos web framework

crows-coordinator

Coordinator server for Crows

leptos_workers

WebWorker library for the Leptos web framework

web-rpc

Bi-directional RPC for the Web

forky_web

Rust Utilities

wai-parser

Parser for WAI syntax

wasmer-c-api-near

Wasmer C API library

wrpc-transport

wRPC core transport functionality

lunars

A compact, WASM-ready spaceship — fueled by Rust-grade hyperdrive! Write scripts that orbit Lua in speed and dock seamlessly with Rust. Smaller than a satellite, built for intergalactic-scale scripting.

wasmenv

version manager for wasm runtimes

ux-components

Backend agnostic GUI framework

virtual-node

A standalone Virtual DOM

wasi-preview1-component-adapter-provider

Embedded wasi-preview1-component-adapter binaries

deno_permissions

deno permissions implementation

webpixels

Libmosh for WebAssembly

wgpu-3dgs-viewer

A 3D Gaussian splatting viewer written in Rust using wgpu

cargo-wasix

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

bounce

The uncomplicated state management library for Yew

geo-nd-wasm

A WASM interface to the geo-nd library

traefik_wasm_api

wasm interface for traefik

web_panic_report

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

xterm-js-sys

Rust WebAssembly bindings for xterm.js

lc3b

LC3B computer emulator

reqwest-wasm

higher level HTTP client library

artwrap

Minimal asynchronous smol/wasm wrapper for unified accessing selected primitives

terrazzo-terminal

web-based terminal emulator built on Terrazzo

warpgate_pdk

Reusable WASM macros and functions for plugin developer kits

wasm_p2p

peer-to-peer library for Rust + WASM, built on top of WebRTC

refilelabs-image

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

rustpython-stdlib

RustPython standard libraries in Rust

wasm-coredump-types

Wasm coredump shared types

wasm-bridge

Run WASM modules on desktop or on the web using wasmtime's API

js-utils

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

custom-element

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

hc-wasmer-compiler-singlepass

Singlepass compiler for Wasmer WebAssembly runtime

tauri-wasm

The tauri framework library for pure rust frontend

wazzup

Very opinionated Rust WASM project builder

elmio-core

core of the Elmio framework

nuts

that offers a simple publish-subscribe API, featuring decoupled creation of the publisher and the subscriber

neo-babylon

A wasm-bindgen-based wrapper for Babylon.js

ambient_std

Ambient standard library extensions

nyar-wasm

High level wasm builder

kerasty

Keras for Rust with support for Web Assembly

wasm-bindgen-test

Internal testing crate for wasm-bindgen

extension_api

自定义wasm plugin 扩展api

suika_wasm

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

wars

Wasm to Rust converter

cbqn

Embed BQN in Rust via CBQN FFI

spawn64

An efficient way to spawn futures in WASM

seed-icons

Get icons collections for Seed

maelstrom-web

Maelstrom WASM web client

wasm_svg_graphics

rendering SVG Graphics with WASM

fluvio-controlplane-metadata

Metadata definition for Fluvio control plane

debug-log

dbg! and eprintln! that only run on debug mode. WASM is supported.

wings

WASM plugin system for Geese

wasm3

Rust bindings for wasm3

sortable-js

bindings to SortableJS, to build sortable lists in wasm

sledgehammer_utils

sledgehammer-bindgen

extension_test

wasm 扩展 test

waaa

WebAssembly, Abstracted Away

witgen

help you generate wit definitions in a wit file for WebAssembly

gs2compiler

Compiles GS2 source code into GS2 bytecode

mago-wasm

Exposes PHP code analysis and tooling functionalities as WebAssembly modules, enabling browser-based tools and editor integrations

arrow-udf-wasm

WebAssembly runtime for Arrow UDFs

yozefu-wasm-types

Types and structures for defining WebAssembly modules

akd_client

Client verification companion for the auditable key directory with limited dependencies

wasmsign2-cli

CLI tool to sign and verify WebAssembly modules

wasm_hex_dump

A CLI tool to convert Wasm files to hexadecimal dumps for libSQL UDFs

ts-rs-json-value

generate typescript bindings from rust types

opslang-wasm

A command and control system for C2A-based satellites

pqc_kyber_kyberslash

post-quantum Kyber KEM algorithm

wasmer-middleware-common

Wasmer runtime common middlewares

cpclib-wasm

webasm tools for cpclib

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…

pax-runtime

Core shared runtime and rendering engine for Pax

mrml-wasm

Wasm wrapping on MRML

makepad-stitch

An experimental Wasm interpreter written in Rust that is designed to be very fast and lightweight

js-component-bindgen

JS component bindgen for transpiling WebAssembly components into JavaScript

emitter-rs

📢 Emitter RS is a lightweight EventEmitter implementation for Rust and Wasm

ic-dummy-getrandom-for-wasm

Workaround a problem with rand on wasm32-unknown-unknown targets

ratio-reactor

Setup WebWorkers as queueing job shop reactors in Yew WASM applications with different strategies

rotext_wasm_bindings

WASM bindings for rust crate rotext

teahttp

a http client for wasm

yew

A framework for creating reliable and efficient web applications

rustpython-vm

RustPython virtual machine

spark-connect-core

Apache Spark Connect Client for Rust

class_list

A reactive helper that ensures normalized class list strings in frontend frameworks like Leptos

ft-sys-shared

ft-sdk: SDK for building FifthTry Applications

uni-gl

Unrust native/wasm openGL/webGL compatibility layer

crb-runtime

CRB | Composable Runtime Blocks | Runtime

wasmprof

allows to profile code running inside of wasmtime