extism is a free, open source browsers & extensions project written in Rust and released under BSD-3-Clause. It has 5,764 GitHub stars, 168 forks and 54 open issues, and was last pushed 15 days ago. On this registry it ranks #56 of 101 tracked projects in Browsers & Extensions, with 5 head-to-head comparisons available.

What is extism?

Extism is a lightweight, BSD-3-Clause-licensed framework for running WebAssembly (Wasm) inside your own application, aimed at developers who want to make software extensible with untrusted, user-supplied plug-in code across servers, the edge, CLIs, IoT devices, and browsers.

What it is

Extism lives in the WebAssembly ecosystem as a framework plus a matched pair of libraries: SDKs that a host application imports, and PDKs (Plug-in Development Kits) that plug-in authors compile into their .wasm binary. The host runs the Extism SDK, loads a WebAssembly module, moves data across the boundary, and calls exported functions. Because the interface is deliberately "universal," the same plug-in contract holds whether the host is a Rust server process, a Node script, a Go CLI, or a browser page.

The concrete problem it solves is executing arbitrary, untrusted code supplied by users without handing that code the run of the machine. Extism is designed for plug-in and extension systems, and it replaces the hand-rolled sandbox, host-function plumbing, and memory management that teams otherwise build directly on top of a raw Wasm runtime. On top of the runtime it adds utilities that standard engines do not provide by default, including persistent memory and module-scope variables, secure host-controlled HTTP that works without WASI, runtime limiters and timers, and simpler host function linking.

Key capabilities

  • Language SDKs that embed the runtime, including Rust (extism on Crates.io), JavaScript (@extism/extism on NPM, supporting Web, Node, Deno, and Bun), Elixir (Hex), Go (Go mod), Haskell (Hackage), Java (Sonatype), .NET for C# and F# (NuGet), OCaml (opam), Perl (CPAN), PHP (Packagist), Python (PyPI), Ruby (RubyGems), Zig, C, and C++.
  • PDKs that let plug-in authors read host input, return data, read provided configuration, get and set variables, and make outbound HTTP calls when the host permits it.
  • Persistent memory and module-scope variables that survive across calls into the same module.
  • Host-controlled HTTP without WASI, so network access stays under the host's authority rather than the plug-in's.
  • Runtime limiters and timers to bound how long plug-in code may run.
  • Simpler host function linking for exposing native capabilities to a module.
  • Prebuilt release targets for aarch64 and x86_64 on apple-darwin, unknown-linux-gnu, unknown-linux-musl, pc-windows-gnu, and pc-windows-msvc.

Who uses it and how

  • Teams building plug-in systems use it to execute user-supplied .wasm modules inside their own process while keeping filesystem and network access under host control.
  • FaaS platforms embed an SDK to run tenant code as short-lived Wasm modules with runtime limiters applied.
  • Web applications use the JS SDK on Web, Node, Deno, or Bun to run modules in the same environment as the page or server.
  • Edge, CLI, and IoT deployments rely on the published musl and gnu builds for Linux plus the Darwin and Windows targets.
  • Code generators and similar tools use PDKs so extension authors can return generated output to the host through the standard interface.

Getting started

Install the SDK for your host language from its package manager, for example extism from Crates.io or @extism/extism from NPM, then refer to the documentation to load a module and call it. Plug-in authors separately add a PDK to their Wasm program so the compiled binary speaks the Extism interface.

How it compares

Among runtimes named in the project's own material, Extism's native path is its set of SDKs across fifteen host languages, while Android is pointed at the separate Chicory SDK, a pure Java Extism runtime. No managed hosting product is described anywhere in the project's facts; Extism is a framework and library set, not a hosted service.

When to use it — and when not

Choose Extism when the host application is yours to modify and you want plug-in execution without designing the sandbox, ABI, and host-function layer from scratch. Be aware that the host team owns everything operational around it: module distribution, sandbox configuration, and HTTP allowlisting, since the project describes no hosted or managed option and names no database, storage, or mail dependencies. Teams wanting a turnkey plug-in marketplace, or Android support without adding the Chicory SDK, are not the intended audience today.

project readme (upstream, from github) — read inline
</a>

Discord GitHub Org's stars Downloads GitHub License GitHub release (with filter)

Overview

Extism is a lightweight framework for building with WebAssembly (Wasm). It supports running Wasm code on servers, the edge, CLIs, IoT, browsers and everything in between. Extism is designed to be "universal" in that it supports a common interface, no matter where it runs.

Note: One of the primary use cases for Extism is building extensible software & plugins. You want to be able to execute arbitrary, untrusted code from your users? Extism makes this safe and practical to do.

Additionally, Extism adds some extra utilities on top of standard Wasm runtimes. For example, we support persistent memory/module-scope variables, secure & host-controlled HTTP without WASI, runtime limiters & timers, simpler host function linking, and more. Extism users build:

  • plug-in systems
  • FaaS platforms
  • code generators
  • web applications
  • & much more...

Supported Targets

We currently provide releases for the following targets:

  • aarch64-apple-darwin
  • aarch64-unknown-linux-gnu
  • aarch64-unknown-linux-musl
  • x86_64-apple-darwin
  • x86_64-pc-windows-gnu
  • x86_64-pc-windows-msvc
  • x86_64-unknown-linux-gnu
  • x86_64-unknown-linux-musl

For Android we suggest taking a look at the Chicory SDK for a pure Java Extism runtime.

Run WebAssembly In Your App

Pick a SDK to import into your program, and refer to the documentation to get started:

Compile WebAssembly to run in Extism Hosts

Extism Hosts (running the SDK) must execute WebAssembly code that has a PDK, or Plug-in Development Kit, library compiled in to the .wasm binary. PDKs make it easy for plug-in / extension code authors to read input from the host and return data back, read provided configuration, set/get variables, make outbound HTTP calls if allowed, and more.

Pick a PDK to import into your Wasm program, and refer to the documentation to get started:

Type Language Source Code Package
Rust PDK Rust PDK https://github.com/extism/rust-pdk Crates.io
JS PDK JS PDK https://github.com/extism/js-pdk N/A
Python PDK Python PDK https://github.com/extism/python-pdk N/A
Go PDK Go PDK https://github.com/extism/go-pdk Go mod
Haskell PDK Haskell PDK https://github.com/extism/haskell-pdk Hackage
AssemblyScript PDK <img alt="As

readme truncated — read the full docs on github

Frequently asked questions

Is extism free to use?

extism is open source under the BSD-3-Clause licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does extism do?

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

What is extism written in?

extism is primarily written in Rust. Its source is publicly available at https://github.com/extism/extism, and it has 5,764 GitHub stars.