Projects using Extism in the wild?

[aschrijver]

In this thread I would like anyone to drop known open source projects that use Extism already. I couldn't easily find examples, but if you know of a project, then don't hesitate and drop a link below :)

[aschrijver]

Moonrepo WASM plugins

Our WASM plugin system is powered by Extism, a Rust-based cross-language framework for building WASM plugins under a unified guest and host API. Under the hood, Extism uses wasmtime as its WASM runtime.

For the most part, you do not need to know about Extism's host SDK, as we have implemented the bulk of it within moon and proto directly. However, you should be familiar with the guest PDKs, as this is what you'll be using to implement Rust-based plugins.

[nilslice]

Thanks, @milesj!

[neuronicnobody]

Simplism

Simplism is a tiny HTTP server to serve Extism WebAssembly plug-ins and execute/call a single WebAssembly function.

[nilslice]

Thanks, @k33g!

[neuronicnobody]

Otorishi WASM plugins

[nilslice]

Thanks, @Zwiterrion!

[neuronicnobody]

Reactables

Reactables bring the power of React and JSX to everyone's programming language of choice. Compile and render JSX templates securely from over 15 different programming languages including Python, Go, Java, Ruby, .NET, PHP, and more!

Reactables is distributed as an Extism Plug-in, so you can now compile and render React/JSX safely from within your programming language of choice.

[nilslice]

Matricks

A command-line tool for extensible LED matrix control with Raspberry Pi devices.

Matricks is a WASM-based extensible LED matrix control tool intended for use on Raspberry Pi devices. LED matrix functionality is defined by user-developed plugins, or "tricks", which can be developed in any language that is supported by the Extism PDK. To simulate plugins while you're developing them, check out Simtricks!

[nilslice]

https://wymcg.github.io/matricks/

[nilslice]

An awesome simulator for the LED panel: https://github.com/wymcg/simtricks

I love how this demonstrates the portability of Wasm so that you can develop your plugin, and test it without any of the hardware. Then run it exactly the same on the hardware device

[nilslice]

Thanks, @wymcg!

[nilslice]

fractal-trick

A Fractal plugin for Matricks

[nilslice]

Thanks, @TheCatster!

[nilslice]

SSD - Simple Service & Data Description

What is SSD?
First and foremost it's supposed to be data format for describing data structures and services. Additionally it provides tooling to work with the aforementioned format, which simplifies writing custom code generators.

https://ssd-codegen.github.io/ssd/

[nilslice]

Thanks, @hardliner66 & @ModProg!

[nilslice]

Image Processing webapp with user-provided plugins

Image processing webapp with user-provided operators

• Developer can implement and upload image operators in WebAssembly format.
• User can apply operators on an image.

[nilslice]

Thanks, @j-blue-arz!

[nilslice]

antz

A small game inspired by AntMe! where you control an ant colony through scripting in order to get more points.

The game is written in Rust and uses ggez as game engine.

[nilslice]

Thanks, @hardliner66!

[nilslice]

unt-rust-ed

Easy interface for taking in untrusted Rust code and executing it at near-native speed in a lightweight and secure sandbox using WASM

This library provides a simple api for taking in some untrusted rust code and executing it. It does this by compiling the rust to wasm, and then runs the wasm in a lightweight container (the containerization is mainly provided by Extism). The main benefit of this crate is that it will change the types as needed, so the untrusted code does not necessarily need to be aware that it will be executed as an Extism plugin. It also will take care of building the code into wasm.

Examples

#[exported_host_type]
pub struct Inputs {
  pub a: i32,
  pub b: i32,
}

impl Inputs {
  fn new(a: i32, b: i32) -> Self {
    Self { a, b}
  }
}

fn main() {
  let rust_code = "pub fn add(inputs: Inputs) -> i32 {\nreturn inputs.a + inputs.b;\n}";       
                                                                                
  let project = UntrustedRustProject::new(rust_code)
    .with_exported_host_type::<Inputs>();                   
                                                                                
  let compiled_project = project.compile().unwrap();

  let mut container = compiled_project.create_container().unwrap();            
                                                                                
  let outputs: i32 = container.call("add", Inputs::new(10, 2)).unwrap();          
                                                                                
  println!("output: {}", outputs); // prints "12"
}

[nilslice]

Thanks, @jebradbury39!

[nilslice]

brack

A bracket-based lightweight markup language that extends commands with WebAssembly

[nilslice]

Thanks, @momeemt!

[srid]

This looks interesting. Are there any information out there? The repo has no README.

[nilslice]

OpenAgents

An open platform for AI agents, built in public from scratch.

Watch this being built!

How it works

• A user creates an Agent from Nodes.
• Nodes are defined by community developers. They could be:
• API endpoints
• External WASM plugins
• Conditional logic
• Data parsing
• Or most anything compatible with flow-based programming
• Nodes may have an associated fee which is paid to the node creator when the node is used in a workflow
• Agents can be used in our UI and via API
• Users can comment/rate/share Nodes
• Leaderboards show what's popular

[nilslice]

Thanks, @AtlantisPleb!

[nilslice]

Flowato

A flow based programming language.

[nilslice]

Thanks, @graham-hughes-code!

[nilslice]

GIF Trick

A Matricks plugin that plays any GIF. By default, this plugin plays catjam, but the plugin can be easily modified to play any other GIF.

[nilslice]

OpenWRT Lua Parser

This is a customized parser for a modified version of luac for openwrt. It can be compiled into WASM and loaded into metaworm's luadec to decompile openwrt's lua script.

[nilslice]

Thanks, @metaworm!

[nilslice]

Libp2peasy, Lemon Squeezy 🍋✊

Ready made Libp2p Rust Server that connects to the IPFS DHT and gossipsib.

Design goal is to have all modules separated for easy re-use in other libraries, and yto use a plugin system to extend the functionality of the server as you need it.

[nilslice]

Thanks, @DougAnderson444!

[nilslice]

ZFlow

Rust implementation of Flow Based Programming Graph specification

This library provides a Rust implementation of a Flow-Based Programming graphs and a runtime for executing the graph. There are two areas covered:

Graph - the actual graph library
Journal trait - journal system for keeping track of graph changes and undo history
Graph Runtime - the process runtime to execute graph components

See full example that demonstrates generation of an HTML code using ZFlow.

[nilslice]

Thanks, @darmie!

[nilslice]

Modsurfer

Use the CLI: https://github.com/dylibso/modsurfer

• Extism is used to run modsurfer.wasm, in particular the parse_module function, which extracts information about any wasm module.

[Zwiterrion]

Wasmo

Server and CLI to build WASM plugin using Extism.

[Zwiterrion]

Wasm4s

A library to easily run WASM vms from inside your Scala project using Extism

[chrisdickinson]

Blextism

---

Blender Wasm bindings to Rust using the Python SDK

A walkthrough video:

[tsirysndr]

Fluent CI Engine

Programmable CI/CD with Extism based plugin system

Usage with GitHub Actions :

name: Deploy
on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Setup Fluent CI
        uses: fluentci-io/setup-fluentci@v5
        with:
           wasm: true
           pipeline: cloudflare
           args: deploy
        env:
          CLOUDFLARE_API_TOKEN: ${{ secrets.CF_API_TOKEN }}
          CLOUDFLARE_ACCOUNT_ID: ${{ env.CF_ACCOUNT_ID }} 

[aschrijver]

Lemmy

Lemmy is a selfhosted social link aggregation and discussion platform. It is completely free and open, and not controlled by any company. This means that there is no advertising, tracking, or secret algorithms. Content is organized into communities, so it is easy to subscribe to topics that you are interested in, and ignore others. Voting is used to bring the most interesting items to the top.

Lemmy, the popular link aggregator for the Fediverse and Free Software decentralized alternative to Reddit, PR'ed a Proof of Concept for their extension mechanism. The PoC will be merged only after first plugins become available. Here's what @Nutomic wrote on the PR:

This PR adds a basic plugin hook using Extism (webassembly), including a simple example plugin written in Go. Plugins can also be written in many other languages like JS, Rust, .NET or C.

For now there are only two plugin hooks available, before and after a new post is created through the local api. However we can add all sorts of plugin hooks, eg for different api actions or incoming federated actions. The question is which plugin hooks are actually needed. So if you are interested in writing Lemmy plugins, please comment below with the hooks that you need.

I dont intend to merge this PR until there is at least a single real-world plugin in development.

[nilslice]

Oura

Oura is a rust-native implementation of a pipeline that connects to the tip of a Cardano node through a combination of Ouroboros mini-protocol (using either a unix socket or tcp bearer), filters the events that match a particular pattern and then submits a succinct, self-contained payload to pluggable observers called "sinks".

Filters

• Parse block / tx CBOR
• Split block into txs
• Select Txs by matching rules (address, metadata, policies, etc)
• Enrich tx data with related inputs
• Custom Typescript code (uses Deno)
• Custom WASM plugin
• Rollback buffer with compensating actions

[nilslice]

Thanks, @scarmuega!