# extism/extism

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/extism-extism).**

5,657 stars · 162 forks · Rust · BSD-3-Clause

## Links

- GitHub: https://github.com/extism/extism
- Homepage: https://extism.org
- awesome-repositories: https://awesome-repositories.com/repository/extism-extism.md

## Topics

`browser` `c` `cpp` `csharp` `dotnet` `elixir` `go` `haskell` `java` `javascript` `node` `ocaml` `plugin-system` `python` `ruby` `rust` `serverless` `wasm` `webassembly` `zig`

## Description

Extism is a cross-language WebAssembly plugin framework that lets applications written in any programming language load and execute plugins written in any other language. It provides a universal plugin system where host applications use idiomatic SDKs to load WebAssembly modules, call exported functions, and pass data back and forth, while plugin authors use development kits that handle memory management and host interaction so they can focus on business logic.

The framework distinguishes itself through its comprehensive approach to cross-language integration, offering schema-driven binding generation that creates type-safe interfaces between host and plugin code from a shared definition. It includes a plugin development kit for each supported language that automatically handles input parsing, output serialization, and host function calls, along with a manifest-based loading system that sets runtime constraints and allowed capabilities before module instantiation. A command-line interface provides tools for invoking plugin functions, scaffolding new plugin projects, and managing the runtime installation.

Extism manages the full lifecycle of plugin systems, from defining plugin interfaces and loading WebAssembly modules to managing persistent module state and testing plugins within a host environment. It handles host-plugin memory management through a shared memory bridge, supports custom host function registration for providing application-specific capabilities to plugins, and enables rapid deployment of plugin systems without building infrastructure from scratch. The framework also provides controlled HTTP request capabilities and configuration reading from the host.

The project includes a runtime manager that installs and checks the version of the shared library required by all host SDKs, and supports compiling plugins from supported languages into WebAssembly binaries for any Extism host environment.

## Tags

### Graphics & Multimedia

- [Cross-Language Host SDKs](https://awesome-repositories.com/f/graphics-multimedia/plugin-sdk-integrations/cross-language-host-sdks.md) — Provides idiomatic host SDKs for multiple languages to integrate WebAssembly plugins into applications.
- [Plug-in Hosting](https://awesome-repositories.com/f/graphics-multimedia/audio-music/audio-processing/plug-in-hosting.md) — Invokes exported functions from a loaded WebAssembly plugin by passing data and receiving results through the host SDK. ([source](https://extism.org/docs/category/concepts))
- [WebAssembly Plugin Loading](https://awesome-repositories.com/f/graphics-multimedia/audio-music/audio-processing/plug-in-hosting/webassembly-plugin-loading.md) — Loads WebAssembly modules as plugins that conform to the host's interface to extend application functionality. ([source](https://extism.org/docs/category/concepts))
- [Cross-Language](https://awesome-repositories.com/f/graphics-multimedia/plugin-sdk-integrations/cross-language.md) — Integrates WebAssembly plugins into applications using idiomatic host SDKs for multiple languages. ([source](https://extism.org/))

### Artificial Intelligence & ML

- [WebAssembly Function Callings](https://awesome-repositories.com/f/artificial-intelligence-ml/function-calling-interfaces/webassembly-function-callings.md) — Calls named functions inside loaded WebAssembly modules and receives return values through the host SDK. ([source](https://extism.org/docs/quickstart/host-quickstart))

### Data & Databases

- [Plugin Development Kit Stubs](https://awesome-repositories.com/f/data-databases/openapi-processors/server-stub-generation/rpc-stub-generation/plugin-development-kit-stubs.md) — Generates boilerplate code in each plugin language that handles input parsing, output serialization, and host function calls.

### Development Tools & Productivity

- [Type-Safe Binding Generators](https://awesome-repositories.com/f/development-tools-productivity/cli-build-tools/ffi-binding-cli-generators/type-safe-binding-generators.md) — Generates type-safe bindings from a shared schema to ensure consistent interfaces across host and plugin languages.
- [Plugin Interface Binding Generators](https://awesome-repositories.com/f/development-tools-productivity/cli-build-tools/ffi-binding-cli-generators/type-safe-binding-generators/plugin-interface-binding-generators.md) — Derives type-safe function signatures and data structures for both host and plugin from a shared interface definition file.
- [Plugin Development Kits](https://awesome-repositories.com/f/development-tools-productivity/plugin-development-kits.md) — Supplies language-specific development kits that abstract Wasm memory management and host interaction for plugin authors.
- [WebAssembly Sandboxing](https://awesome-repositories.com/f/development-tools-productivity/plugin-systems/webassembly-sandboxing.md) — Sandboxes WebAssembly module execution to prevent malicious code from harming the host application. ([source](https://extism.org/))
- [Multi-Language Plugin Executions](https://awesome-repositories.com/f/development-tools-productivity/tool-integration-plug-ins/multi-language-plugin-executions.md) — Loads and executes user-defined functions from WebAssembly modules to accept custom logic from any supported host language. ([source](https://extism.org/docs/overview))
- [Plugin Interface Definitions](https://awesome-repositories.com/f/development-tools-productivity/tool-integration-plug-ins/plugin-interface-definitions.md) — Defines the interface contract between host applications and WebAssembly plugins. ([source](https://extism.org/docs/overview))
- [Sandboxed Plugin Execution](https://awesome-repositories.com/f/development-tools-productivity/tool-integration-plug-ins/sandboxed-plugin-execution.md) — Runs untrusted WebAssembly code in a sandboxed environment to prevent plugins from accessing the host system. ([source](https://extism.org/docs/overview))
- [Plugin Binding Generators](https://awesome-repositories.com/f/development-tools-productivity/cli-build-tools/ffi-binding-cli-generators/type-safe-binding-generators/plugin-binding-generators.md) — Creates type-safe bindings between host and plugin code from a shared schema for consistent interfaces across languages. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [Library-Based](https://awesome-repositories.com/f/development-tools-productivity/plugin-systems/library-based.md) — Integrates a ready-made, library-based plugin system into applications quickly without building infrastructure from scratch. ([source](https://extism.org/))
- [WebAssembly Plugin Scaffolders](https://awesome-repositories.com/f/development-tools-productivity/project-scaffolding-config-code-generation/project-scaffolding-configuration/project-scaffolding/project-scaffolders/webassembly-plugin-scaffolders.md) — Scaffolds new plugin projects from templates to quickly start writing WebAssembly modules. ([source](https://extism.org/docs/install))

### DevOps & Infrastructure

- [Code Execution Sandboxes](https://awesome-repositories.com/f/devops-infrastructure/execution-environments/code-execution-runtimes/code-execution-sandboxes.md) — Executes user-provided WebAssembly modules in a sandboxed environment to prevent malicious actions. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [Library-Based Plugin Systems](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/javascript-plugin-systems/library-based-plugin-systems.md) — Provides a library-based plugin system that can be integrated into applications quickly to enable extensibility.
- [WebAssembly Plugin Systems](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/javascript-plugin-systems/user-uploaded-plugin-systems/webassembly-plugin-systems.md) — Loads and executes user-provided WebAssembly modules as plugins to extend application functionality. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [WebAssembly Cross-Language Plugin Development](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/multi-language-plugin-frameworks/webassembly-cross-language-plugin-development.md) — Writes and runs WebAssembly plugins in one language and integrates them into host applications written in a different language.
- [Plugin Development Kits](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/plugin-development-kits.md) — Supplies plugin development kits that handle input, output, configuration, state, and HTTP calls so authors focus on business logic. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [WebAssembly Plugins](https://awesome-repositories.com/f/devops-infrastructure/release-automation/plugin-extensibility/webassembly-plugins.md) — Provides an extensible framework for building plugin systems that load and execute WebAssembly modules from any programming language.

### Programming Languages & Runtimes

- [Secure Wasm Sandboxes](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/execution-mode-engines/webassembly-execution-modes/secure-wasm-sandboxes.md) — Runs untrusted WebAssembly modules in an isolated environment that restricts system access to only explicitly permitted host functions.
- [Multi-Language Host SDKs](https://awesome-repositories.com/f/programming-languages-runtimes/cross-language-library-development/multi-language-host-sdks.md) — Provides idiomatic bindings in multiple programming languages that wrap the same shared C library for consistent plugin loading.
- [Cross-Language Runtime Integration](https://awesome-repositories.com/f/programming-languages-runtimes/cross-language-runtime-integration.md) — Integrates WebAssembly plugins into applications written in any language using idiomatic host SDKs. ([source](https://extism.org/docs/overview))
- [Host Function Exposure](https://awesome-repositories.com/f/programming-languages-runtimes/host-function-exposure.md) — Exposes application-defined functions to plugins so they can call back into the host for additional capabilities. ([source](https://extism.org/docs/category/concepts))
- [WebAssembly](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/rust/function-exports/webassembly.md) — Exposes named functions from WebAssembly modules so the host can invoke them with input and receive return values. ([source](https://extism.org/docs/quickstart/plugin-quickstart))
- [Host-Wasm Shared Memory Buffers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-wasm-runtimes/host-wasm-shared-memory-buffers.md) — Manages shared memory buffers between host and WebAssembly modules for two-way data exchange. ([source](https://extism.org/docs/concepts/pdk))
- [Plugin Hosting](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/plugin-hosting.md) — Loads compiled WebAssembly modules into the host and prepares them for function calls. ([source](https://extism.org/docs/quickstart/host-quickstart))
- [Host-Plugin Memory Managers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/plugin-hosting/host-plugin-memory-managers.md) — Manages data transfer and shared memory between a host application and WebAssembly plugins for safe two-way communication.
- [Host-Plugin Memory Transfers](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/plugin-hosting/host-plugin-memory-transfers.md) — Manages memory transfer between the host and a WebAssembly module so variables and arguments cross the boundary safely. ([source](https://extism.org/docs/category/concepts))

### Security & Cryptography

- [Wasm Sandboxes](https://awesome-repositories.com/f/security-cryptography/application-and-system-security/sandbox-and-isolation/isolated-execution-sandboxes/wasm-sandboxes.md) — Executes arbitrary WebAssembly code safely inside a host application by isolating it from the system. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))

### Software Engineering & Architecture

- [Extensible Plugin Architectures](https://awesome-repositories.com/f/software-engineering-architecture/extensible-plugin-architectures.md) — Creates plugin architectures where users supply WebAssembly modules that interact with the host through a defined interface. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [Plugin Extenders](https://awesome-repositories.com/f/software-engineering-architecture/integration-extensibility/extensibility/plugin-architectures/developer-authoring-interfaces/custom-module-implementations/module-functionality-extenders/plugin-extenders.md) — Defines integration points where end-users inject custom logic via WebAssembly modules to extend application functionality. ([source](https://extism.org/docs/overview))
- [Manifest-Based Plugin Loading](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/plugin-module-systems/modular-plugin-architectures/plugin-based-architectures/plugin-based-architectures/manifest-based-plugin-loading.md) — Loads a WebAssembly module with a declarative manifest that sets runtime constraints and allowed capabilities before instantiation.
- [Plugin Manifests](https://awesome-repositories.com/f/software-engineering-architecture/configuration-manifests/plugin-manifests.md) — Defines plugin runtime constraints and settings in a manifest blueprint before loading into the host. ([source](https://extism.org/docs/category/concepts))
- [WebAssembly CLI Plugin Invokers](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/plugin-module-systems/modular-plugin-architectures/plugin-based-architectures/hook-based-plugin-systems/cli-plugin-systems/webassembly-cli-plugin-invokers.md) — Calls exported functions in WebAssembly modules with arguments and flags directly from the command line. ([source](https://extism.org/docs/install))

### Web Development

- [Schema-Driven Plugin Bindings](https://awesome-repositories.com/f/web-development/schema-driven-api-generators/typed-language-bindings/schema-driven-plugin-bindings.md) — Generates type-safe bindings from a shared schema to ensure consistent interfaces across host and plugin languages. ([source](https://cdn.jsdelivr.net/gh/extism/extism@main/README.md))
- [Plugin Compilation to WebAssembly](https://awesome-repositories.com/f/web-development/webassembly-compilation/plugin-compilation-to-webassembly.md) — Compiles source code written in supported languages into WebAssembly binaries for use as plugins. ([source](https://extism.org/docs/concepts/pdk))

### Part of an Awesome List

- [Runtime and Embeddings](https://awesome-repositories.com/f/awesome-lists/devtools/runtime-and-embeddings.md) — Universal plug-in system powered by WebAssembly.