#plugin #wasi #inventory #plugy

macro plugy-macros

plugy empowers you to construct agnostic dynamic plugin systems using Rust and WASM

5 unstable releases

new 0.3.0 Dec 3, 2023
0.2.1 Aug 31, 2023
0.2.0 Aug 16, 2023
0.1.1 Aug 9, 2023
0.1.0 Aug 8, 2023

#10 in #plugin-system

48 downloads per month
Used in plugy


315 lines

GitHub Actions GitHub Releases


plugy is a plugin system designed to enable the seamless integration of Rust-based plugins into your application. It provides a runtime environment for loading and executing plugins written in WebAssembly (Wasm), enabling dynamic extensibility and modularity in your Rust projects.


  • Load and execute plugins compiled to WASM.
  • Flexible runtime management of plugins.
  • Calls to plugin functions are async.
  • Easy-to-use macros for generating plugin interfaces.

Getting Started

To use plugy in your Rust project, follow these steps:

  1. Write your plugin trait:
trait Greeter {
    fn greet(&self) -> String;
  1. Write your first plugin implementation
#[derive(Debug, Deserialize)]
struct FooPlugin;

impl Greeter for FooPlugin {
    fn greet(&self) -> String {
        "Hello From Foo Plugin".to_owned()

Compile it!

cargo build --target wasm32-unknown-unknown
  1. Import and run
#[plugin_import(file = "target/wasm32-unknown-unknown/debug/foo_plugin.wasm")]
struct FooPlugin;

async fn main() {
    let runtime = Runtime::<Box<dyn Greeter>>::new().unwrap();
    let handle = runtime.load(FooPlugin).await.unwrap();
    let res = handle.greet().await;
    assert_eq!(res, "Hello From Foo Plugin")

And you are set!


Check out the examples directory for sample usage of plugy.


Status Goal Labels
accept multiple arity (n-ary) in plugin functions complete
pass down context between host and guest complete


Plugy comprises three fundamental crates, each serving a distinct role in crafting dynamic plugin systems with Rust and WebAssembly:

  • core: This crate houses essential components such as bitwise utilities and the guest module, forming the foundation of Plugy's functionality.

  • runtime: The runtime crate orchestrates the execution of your plugin system, allowing seamless integration of plugins into your applications.

  • macros: The macros crate offers a collection of macros that simplify the generation of bindings and interfaces, streamlining the process of working with dynamic plugins.


Contributions to plugy are welcome! If you find a bug or want to propose a new feature, feel free to create an issue or submit a pull request.

Thanks to


This project is licensed under the MIT OR Apache-2.0 License.


~35K SLoC