Skip to content
CAI
Software that uses CAICheck a score

extism/extism

54.4

Adequate · 14 November 2026

5.9k

lines of production code

Rust

with C

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Extism is a portable WebAssembly runtime and SDK framework that enables the execution of isolated plugins with strict resource management and secure host interactions. It provides a unified Rust core, a C library for native integration, and a Python binding, while supporting rich data serialization and configuration via a formal manifest schema. The system focuses on performance and safety through a modernized kernel, plugin pooling, and comprehensive benchmarking, having consolidated its language support to prioritize Rust, C, and Python.

How it got here

2022 — Runtime modernization and SDK cleanup

19 changes.

The project upgraded its runtime to Wasmtime 48 and restructured the codebase into a Cargo workspace, introducing a new plugin API and manifest schema. Concurrently, legacy SDKs for C++, Go, Node.js, OCaml, Python, and Ruby were removed to streamline development and focus on core C and Rust interfaces.

2023–2024 — Kernel rewrite and SDK expansion

10 changes.

The project rewrote the Extism kernel in Rust and WebAssembly to improve portability and establish a robust memory management foundation. This period also focused on expanding language support by introducing the extism-convert crate for data serialization, a new C SDK, and Python wheel building capabilities, while adding comprehensive testing and benchmarking suites.

Features

Added extism-maturin crate for building Python wheels

A new extism-maturin crate has been introduced to facilitate the creation of Python wheels for the Extism SDK. This crate includes a build script that preprocesses the C header file (extism.h) to handle platform-specific compatibility issues on macOS and Windows, and exposes the SDK's public API via Rust bindings for Python integration.

extism-maturin · high confidence

Introduce extism-convert crate for plugin data serialization

The new \extism-convert\ crate provides a shared interface for encoding and decoding values passed to and from Extism plugin calls, used by the Rust SDK and PDK. It introduces \ToBytes\ and \FromBytes\ traits with derive macros, supporting JSON, MessagePack, Protobuf (via \prost\ and \rust-protobuf\), Base64, and raw memory copying (via \bytemuck\). Built-in implementations cover primitive types, \Option\, and standard collections, enabling users to easily serialize/deserialize data for function inputs and outputs.

convert · high confidence

Introduction of the Extism kernel runtime in WebAssembly

The Extism kernel runtime is now implemented in WebAssembly, providing an isolated memory space for plugins with a bump allocator, input/output handling, and error management. This change introduces the core \MemoryRoot\ and \MemoryBlock\ structures, along with functions for memory initialization, resetting, and bounds checking, establishing the foundation for plugin execution within the kernel.

kernel/src · high confidence

New derive macros for automatic ToBytes and FromBytes conversion

The \convert-macros\ crate now provides \\#\[derive(ToBytes)\]\ and \\#\[derive(FromBytes)\]\ macros, allowing users to automatically implement byte serialization and deserialization for structs by specifying an encoding via the \\#\[encoding(...)\]\ attribute. The implementation includes robust compile-time validation, providing clear error messages and suggestions when the encoding attribute is missing, malformed, or duplicated.

convert-macros · high confidence

New runtime examples for file I/O, module linking, logging, and host functions

Added four new example programs in the runtime examples directory to demonstrate key Extism capabilities. The \fs.rs\ example shows how to configure read-only allowed paths and handle file read/write operations via WASI. The \linking.rs\ example demonstrates runtime module linking, where an export from one WASM module (\upper.wasm\) is linked to an import in another (\reflect.wasm\). The \log\_callback.rs\ example illustrates how to register a custom log callback to capture tracing output from plugins. The \readme.rs\ example provides a complete implementation of the README usage pattern, showing how to define and register host functions (\kv\_read\, \kv\_write\) that interact with user data (a key-value store) inside the plugin.

runtime/examples · high confidence

libextism C SDK: new build system, API, and example

The libextism location now provides a complete C SDK package. A new CMakeLists.txt enables building and installing both static and shared libraries, along with pkg-config files (extism.pc, extism-static.pc) for easy integration. The API documentation (API.md) and README.md have been added, detailing the C FFI interface (e.g., extism\_plugin\_new, extism\_plugin\_call, extism\_plugin\_reset, logging functions). An example program (example.c) demonstrates usage, including custom host functions and logging. This establishes the foundational build and documentation structure for the C SDK.

libextism · high confidence

Removals

Removal of C++ SDK and example code

The C++ SDK files, including the C++ wrapper header (extism.hpp), the C header (extism.h), the example application (example.cpp), and the build instructions (Makefile), have been removed from the repository. This eliminates the C++ language binding and its associated demonstration code from the project.

cpp · high confidence

Removal of Node.js JavaScript SDK and example

The Node.js JavaScript SDK implementation (node/index.js) and its accompanying example script (node/example.js) have been removed. This deletes the previous JavaScript-based interface that relied on ffi-napi to interact with the native libextism library, effectively removing the ability to use Extism from Node.js via this specific JavaScript wrapper.

node · high confidence

Removal of OCaml CLI binary and build configuration

The \extism\ executable and its associated \dune\ build configuration have been removed from the \ocaml/bin\ directory. This deletes the command-line tool that previously allowed users to invoke Extism functions (such as \count\_vowels\) directly via the \extism\ binary, effectively removing this specific CLI interface from the SDK distribution.

ocaml/bin · high confidence

Removal of OCaml SDK library files

The \extism\ OCaml library source files (\extism.ml\, \extism.mli\) and its build configuration (\dune\) have been removed from the \ocaml/lib\ directory. This deletes the OCaml bindings that previously allowed users to register plugins, call functions, and handle manifests via the \extism\ module.

ocaml/lib · high confidence

Removal of Python example script

The Python example script (example.py) has been removed from the repository. This file previously demonstrated how to instantiate an Extism Plugin, load a WebAssembly module, and invoke the count\_vowels function, providing a reference implementation for Python users.

python · high confidence

Removal of Ruby SDK scaffolding and example files

The Ruby SDK directory has been cleaned up by removing several development and scaffolding files, including the Rakefile, bin/console, bin/setup, example.rb, and the RBS type signature file (sig/extism.rbs). This change removes the local development helpers and example usage code from the repository, likely as part of a broader cleanup or restructuring of the SDK's distribution contents.

ruby · high confidence

Removal of Ruby SDK version constant

The \ruby/lib/extism/version.rb\ file has been deleted, removing the \Extism::VERSION\ constant that previously exposed the SDK version (0.1.0). This change eliminates the programmatic access to the library's version number from the Ruby codebase.

ruby/lib/extism · high confidence

Removal of legacy Extism PDK bindings and Host implementation

The \wasm/rust-pdk\ module has removed its previous implementation of the Extism PDK, specifically deleting \src/bindings.rs\ (which defined FFI declarations for Extism host functions and memory helpers) and \src/lib.rs\ (which provided the \Host\ struct and associated abstractions for input, output, configuration, and key-value storage). This change eliminates the old PDK code from this location, likely as part of a migration to a different PDK version or structure.

wasm/rust-pdk · high confidence

Removal of legacy OCaml SDK build and dependency files

The \ocaml\ directory has removed its legacy build configuration and dependency management files, including \.ocamlformat\, \dune-project\, \extism.opam\, and \extism.opam.locked\. This cleanup eliminates the project's previous Opam package definition and pinned dependency list (which included libraries like \ctypes-foreign\, \bigstringaf\, and \yojson\), indicating a shift away from the standalone Opam-based build system for this location.

ocaml · high confidence

Removal of legacy Ruby SDK implementation

The legacy Ruby SDK implementation in \ruby/lib/extism.rb\ has been removed. This file previously provided a basic interface for registering and calling WebAssembly plugins using FFI bindings to the \extism\ library, including error handling and output retrieval. Users relying on this specific Ruby module will no longer have access to these direct FFI-based plugin interactions.

python/extism, ruby/lib · high confidence

Removal of legacy WebAssembly PDKs and build artifacts

The legacy WebAssembly platform development kits (PDKs) and their associated build infrastructure have been removed. This change deletes the C PDK header (\wasm/c-pdk/extism-pdk.h\), the C example (\wasm/count\_vowels.c\), the Rust PDK example (\wasm/rust-pdk/examples/count\_vowels.rs\), and the Makefiles used to compile them. Users relying on these specific C and Rust WASM examples or the old PDK headers for direct integration will need to migrate to the current runtime implementation.

wasm · high confidence

Removed Go example application

The Go example application (main.go) that demonstrated loading a plugin manifest, executing the count\_vowels function, and parsing the JSON output has been removed from the repository.

go · high confidence

API

Extism C API refactored with expanded types and C++ compatibility

The Extism C API (\extism.h\) has been significantly expanded and restructured to support richer plugin interactions. The previous simple \ExtismPlugin\ integer handle is replaced by a full struct (\ExtismPlugin\) and new opaque types like \ExtismCompiledPlugin\, \ExtismFunction\, and \ExtismCurrentPlugin\. The API now exposes detailed value handling via \ExtismVal\ and \ExtismValUnion\ enums, allowing host functions to accept and return multiple typed arguments (I32, I64, F32, F64, etc.) rather than just raw pointers. New capabilities include pre-compiling plugins (\extism\_compiled\_plugin\_new\), setting host function namespaces, retrieving plugin IDs, and accessing the current plugin's memory directly from host functions. The header also adds C++ compatibility macros (\EXTISM\_FUNCTION\, \EXTISM\_GO\_FUNCTION\) and an \EXTISM\_PTR\ alias for I64, while the build process now explicitly generates these bindings with C++ support enabled.

runtime · high confidence

Behavioural changes

Introduce Extism kernel as a portable WebAssembly runtime core

The Extism runtime core has been rewritten in Rust and compiled to WebAssembly to improve portability across different WebAssembly runtimes. This change introduces a new build process for the kernel, allowing users to generate the \extism-runtime.wasm\ binary and merge it with context modules, while also providing a dedicated test script using \wasm-bindgen-test-runner\ for validation.

kernel · high confidence

Manifest schema and API overhaul: new memory/config options, WASI paths, and HTTP host restrictions

The manifest crate has been refactored to introduce a formal JSON Schema (\schema.json\) and significantly expand configuration capabilities. Users can now restrict network access via \allowed\_hosts\, map local directories into the WASI environment using \allowed\_paths\, and configure memory limits more granularly (max pages, max HTTP response size, and max var bytes). The \Wasm\ module definition now supports raw binary data without base64 encoding, and the \HttpRequest\ builder provides a fluent API for setting headers and methods. These changes are accompanied by stricter serialization rules (\deny\_unknown\_fields\) and deprecation of older \ManifestMemory\ and \ManifestWasm\ types in favor of the new \MemoryOptions\ and \Wasm\ structures.

manifest · high confidence

New libextism crate for generating the shared library

A new \libextism\ crate has been added to facilitate the generation of the \libextism\ shared library by re-exporting the SDK from the \extism\ crate. This change consolidates the build process, allowing the runtime and SDK to be unified under a single entry point for library generation, while including a basic test to verify the version string is correctly populated.

libextism/src · high confidence

Release workflow documentation and build system updates

Added DEVELOPING.md to document the release process, including branching strategies, tagging, and CI workflows for publishing artifacts. Updated the Makefile to support static library builds (installing libextism.a), pkg-config files, and cross-compilation via RUST\_TARGET. Added a new example-schema.yaml for XTP Bindgen and updated .gitignore to exclude generated files from various SDKs. Removed the legacy extism.go and libextism.pc files, and refreshed README.md with current SDK support graphics and links.

(repo-wide) · high confidence

Restore NuGet packaging infrastructure for Extism runtime

The NuGet packaging configuration for the Extism runtime has been restored, enabling the distribution of the library as a NuGet package. This change re-introduces the necessary build assets, including \Directory.Build.props\ for standardizing build properties (targeting .NET Standard 2.1) and versioning via MinVer, alongside the \Extism.runtime.all.nuspec\ manifest which aggregates platform-specific native dependencies (Linux, macOS, Windows) into a single internal implementation package. A \.gitignore\ and \README.md\ are also included to support the packaging workflow.

nuget · high confidence

Runtime refactored to use Wasmtime 48 and modernized plugin API

The runtime has been upgraded to Wasmtime 48 (LTS) and restructured to use a new \CurrentPlugin\ context instead of the previous global plugin registry. This change introduces a \PluginBuilder\ for configuring plugins (including WASI, fuel limits, and caching), a thread-safe \Pool\ for managing plugin instances, and a new \UserData\ system for host functions. The old \export.rs\ and \memory.rs\ modules have been removed in favor of the new \pdk.rs\ and \current\_plugin.rs\ implementations, and logging now uses the \tracing\ crate with a configurable callback.

runtime/src · high confidence

Rust SDK removes legacy C FFI bindings and build scripts

The Rust SDK has removed the \Makefile\, \build.rs\, and \src/bindings.rs\ files that previously handled building and binding to the C library (\libextism.so\/\.dylib\). This change eliminates the manual C-FFI layer and build-time dependency on the external C shared library for the Rust crate, simplifying the build process and removing the generated bindings code.

rust · high confidence

Test coverage

Add benchmarking suite for plugin creation and data throughput; Added runtime test suite for kernel, plugin pooling, and issue regression.

Dependencies

Extism runtime upgraded to Wasmtime 48 and restructured into a Cargo workspace

The Extism runtime has been upgraded to Wasmtime version 48, bringing support for new features such as the GC proposal, coredumps, and parallel compilation. The project structure has been reorganized into a Cargo workspace, centralizing version management and dependencies across the \extism\, \extism-convert\, \extism-manifest\, and \libextism\ crates. This update also introduces \tracing\ for logging, adds \extism-convert\ for type serialization, and updates build tools like \cbindgen\ to version 0.29. Additionally, the old Node.js, Python, Ruby, and Go SDK directories have been removed, with the Python SDK now built via \extism-maturin\ for CFFI bindings.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 55 → 54 (-0.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 70 → 63 (-7.0)
  • Architecture 67 → 67 (+0.0)
  • Maturity 70 → 70 (+0.0)
  • Readiness 76 → 75 (-0.9)
  • Security 39 → 41 (+2.5)

Resolved (10)

  • Coverage not measured — no coverage collector is wired up
  • Duplicated block (10 lines × 2) (runtime/src/sdk.rs)
  • Duplicated block (11–13 lines × 4) (runtime/src/sdk.rs)
  • Duplicated block (12 lines × 2) (runtime/src/sdk.rs)
  • Duplicated block (18 lines × 2) (runtime/src/sdk.rs)
  • Duplicated block (8 lines × 4) (runtime/src/sdk.rs)
  • Duplicated block (9 lines × 2) (runtime/src/sdk.rs)
  • High secret: WD-SECRET-0005 (browser/package-lock.json)
  • Near-duplicate member family (4 members, 19 shared lines) (runtime/src/sdk.rs)
  • Rotate the exposed credentials — git history can't be un-committed

New (9)

  • Duplicated block (15 lines × 2) (runtime/src/sdk.rs)
  • Duplicated block (26–28 lines × 4) (runtime/src/sdk.rs)
  • Edited copy of a member (13 corresponding lines) (runtime/src/current_plugin.rs)
  • Edited copy of a member (13 corresponding lines) (runtime/src/plugin.rs)
  • Edited copy of a member (16 corresponding lines) (runtime/src/current_plugin.rs)
  • Edited copy of a member (19 corresponding lines) (runtime/src/lib.rs)
  • Edited copy of a member (24 corresponding lines) (runtime/src/current_plugin.rs)
  • Edited copy of a member (28 corresponding lines) (runtime/src/pdk.rs)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (runtime/src/sdk.rs)

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

extism/extism was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 051b765bb6abe4fe95d5e4f489f03ad7b137edbc — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.