Build plugins without the pain.

1. 1

   Creating a new project

   Pumpkin plugins use the Cargo build system.

   The complete code for this plugin can be found as a template on GitHub.

2. 2

   Installing the toolchain

   Before we can compile a plugin, we have to have the wasm32-wasip2 target installed. You can install the target by running:

   rustup target add wasm32-wasip2

3. 3

   Initializing a new crate

   First we need to create a new project folder. You can do this by running this command in the folder you created:

   cargo new <project-name> --lib

   After adding this, we want to create a new directory called .cargo and add in a config.toml file with the following contents:

   [build]target = "wasm32-wasip2"

   Altogether your new folder structure should look like this:

   ├── .cargo/│   └── config.toml├── src/│   └── lib.rs├── Cargo.toml└── Cargo.lock

4. 4

   Configuring the crate

   Since Pumpkin plugins are loaded at runtime as dynamic libraries, we need to tell Cargo to build this crate as one.

   [package]name = "hello-pumpkin-wasm"version = "0.1.0"edition = "2024" [lib] crate-type = ["cdylib"] [dependencies]

   Next we need to add some basic dependencies. Since Pumpkin is still in early development, the internal crates aren't published to crates.io, so we need to tell Cargo to download the dependencies directly from GitHub.

   [package]name = "hello-pumpkin"version = "0.1.0"edition = "2024" [lib]crate-type = ["cdylib"] [dependencies]# This is the api crate that makes creating plugins easier, and has wit definitionspumpkin-plugin-api = { version = "0.1.0", git = "https://github.com/Pumpkin-MC/Pumpkin", package = "pumpkin-plugin-api" }tracing = "0.1"

The full walkthrough is in the Rust documentation.

1. 1

   Installation

   First, you need to install the pumpkin-api-py library:

   pip install pumpkin-api-py

2. 2

   Creating your first plugin

   Create a file named main.py and add the following content:

   from pumpkin_api import (    Plugin, PluginMetadata, register_plugin,     server, event, command, text, context) class MyPlugin(Plugin):    def metadata(self) -> PluginMetadata:        return PluginMetadata(            name="my-plugin",            version="0.1.0",            authors=["you"],            description="An example plugin."        )     def on_load(self, ctx: context.Context) -> None:        print("Python plugin loaded!")                # Register an event handler        self.register_event(ctx, event.EventType.PLAYER_JOIN_EVENT, self.on_player_join)     def on_player_join(self, srv: server.Server, evt: event.PlayerJoinEventData) -> event.PlayerJoinEventData:        print(f"Player {evt.player.get_name()} joined!")        return evt register_plugin(MyPlugin)

3. 3

   Building the plugin

   Build your plugin into a WebAssembly component using the provided build tool:

   pumpkin-api-build main -o my_plugin.wasm

   This will generate a my_plugin.wasm file that you can place in the plugins folder of your Pumpkin server.

The full walkthrough is in the Python documentation.

1. 1

   Installation

   You will need the .NET SDK and the WASI workload to compile C# plugins for Pumpkin.

   dotnet workload install wasi-experimental

2. 2

   Creating your first plugin

   Create a new class library and add the following code:

   using Pumpkin.API; public class MyPlugin : IPlugin {    public PluginMetadata GetMetadata() => new() {        Name = "my-csharp-plugin",        Version = "0.1.0",        Authors = new[] { "you" },        Description = "A simple C# plugin for Pumpkin"    };     public void OnLoad(IContext ctx) {        Console.WriteLine("C# plugin loaded!");    }}

3. 3

   Building the plugin

   Compile the plugin to WebAssembly using the WASI runtime identifier:

   dotnet build -c Release /p:RuntimeIdentifier=wasi-wasm

   This will generate a .wasm file in your output directory that can be loaded by Pumpkin.

The full walkthrough is in the C# documentation.

1. 1

   Installation

   You will need the wasi-sdk to compile C/C++ plugins for Pumpkin. Download the latest release from the wasi-sdk repository.

   The complete code for this plugin can be found in the pumpkin-api-c repository.

2. 2

   Creating your first plugin

   Create a file named main.c and add the following content:

   #include "pumpkin_api.h"#include <stdio.h> // Define the plugin's metadatapumpkin_metadata_t get_meta(void) {    static const char* authors[] = {"you"};    return (pumpkin_metadata_t) {        .name = "my-c-plugin",        .version = "0.1.0",        .authors = authors,        .authors_count = 1,        .description = "A simple C plugin for Pumpkin",        .dependencies_count = 0    };} // Callback executed when the plugin is loadedvoid on_load(plugin_own_context_t ctx) {    printf("C plugin loaded!\n");} // Register the plugin with the APIREGISTER_PUMPKIN_PLUGIN(((pumpkin_plugin_t){    .get_metadata = get_meta,    .on_load = on_load}))

3. 3

   Building the plugin

   To compile this plugin into a WebAssembly component, use clang from the wasi-sdk:

   /path/to/wasi-sdk/bin/clang -O3 \ -Iinclude -Isrc/gen \ src/gen/plugin.c src/pumpkin_api.c main.c \ -o my_plugin.wasm \ -mexec-model=reactor

   This will generate a my_plugin.wasm file that can be loaded by Pumpkin.

The full walkthrough is in the GitHub repository.

1. 1

   Installation

   You will need Go 1.23 or later and tinygo to compile Go plugins for Pumpkin.

   brew tap tinygo-org/tools && brew install tinygo

2. 2

   Creating your first plugin

   Create a file named main.go and add the following content:

   package main import (    "fmt"    "github.com/pumpkin-mc/pumpkin-api-go") type MyPlugin struct{} func (p *MyPlugin) Metadata() pumpkin.PluginMetadata {    return pumpkin.PluginMetadata{        Name:        "my-go-plugin",        Version:     "0.1.0",        Authors:     []string{"you"},        Description: "A simple Go plugin for Pumpkin",    }} func (p *MyPlugin) OnLoad(ctx pumpkin.Context) {    fmt.Println("Go plugin loaded!")} func main() {    pumpkin.RegisterPlugin(&MyPlugin{})}

3. 3

   Building the plugin

   Compile the plugin to WebAssembly using tinygo:

   tinygo build -o my_plugin.wasm -target=wasi main.go

   This will generate a my_plugin.wasm file that can be loaded by Pumpkin.

The full walkthrough is in the Go documentation.

1. 1

   Installation

   You will need a number of things installed.

   • Git
   • JDK 17+
   • Rust (only default/host toolchain)
   • wasm-tools
   • make (e.g. GNU Make)

   Unlike most of the other APIs, this one is actually a template instead. Clone it and rename.

   git clone --recurse-submodules https://github.com/Pumpkin-MC/pumpkin-api-ktmv pumpkin-api-kt my_kotlin_plugincd my_kotlin_plugin

   Then change the rootProject.name in settings.gradle.kts, and the PROJECT_NAME in Makefile. They must both match. Whatever you name the project is going to be the filename of the Wasm produced.

2. 2

   Creating your first plugin

   The template already has some code prepared. src/wasmWasiMain/kotlin/plugin/Plugin.kt contains:

   package plugin; import pumpkin.* class PluginRootFunctionsExportsImpl {    companion object : PluginRootFunctions.Exports {        override fun initPlugin() {            Logging.log(Logging.Level.INFO, "Init Kotlin plugin!")        }         override fun onLoad(context: Context.Context): Result<Unit> {            Logging.log(Logging.Level.INFO, "Load Kotlin plugin!")            return Result.success(Unit)        }         override fun onUnload(context: Context.Context): Result<Unit> {            Logging.log(Logging.Level.INFO, "Unload Kotlin plugin!")            return Result.success(Unit)        }         override fun handleCommand(            commandId: UInt,            sender: Command.CommandSender,            server: Server.Server,            args: Command.ConsumedArgs        ): Result<Int> {            TODO("Not yet implemented")        }         override fun handleEvent(eventId: UInt, server: Server.Server, event: Event.Event): Event.Event {            TODO("Not yet implemented")        }         override fun handleTask(handlerId: UInt, server: Server.Server) {            TODO("Not yet implemented")        }    }} class MetadataImpl {    companion object : Metadata {        override fun getMetadata(): Metadata.PluginMetadata {            return Metadata.PluginMetadata(                name = "Example Kotlin Plugin",                version = "0.1.0",                authors = listOf("You"),                description = "An example plugin written in Kotlin",                dependencies = listOf(),                permissions = listOf()            );        }    }} 

3. 3

   Building the plugin

   Compile the plugin to WebAssembly by running the Makefile:

   make

   This will take a while the first time as it builds some Rust dependencies from source.

   Once it is done, my_kotlin_plugin.wasm (or whatever your Gradle project name is) will appear in build, ready to load into Pumpkin.

The full walkthrough is in the Kotlin documentation.

1. 1

   Installation

   You will need LDC 1.43 or later with the addon-wasi package installed, and DUB.

   The bindings come from the pumpkin-api-d package. Declare it in a dub.json next to your plugin:

   {    "name": "my-d-plugin",    "description": "A minimal Pumpkin plugin built with D.",    "license": "proprietary",    "authors": ["You"],    "copyright": "Copyright © 2026, You",     "dependencies": {        "pumpkin-api-d": "~>0.1.0"    },     "targetType": "executable",    "dflags": ["-Xcc=-mexec-model=reactor"],    "buildTypes": {        "debug": {            "buildOptions": ["debugMode", "debugInfo"]        },        "release": {            "buildOptions": ["optimize", "inline"],            "dflags": ["-L-S"]        }    }}

2. 2

   Creating your first plugin

   Then put the plugin itself in source/app.d:

   module plugin; import wit.pumpkin.plugin.plugin;import wit.common;import pumpkin.register; struct MyPlugin {    @GetMetadata PluginMetadata getMetadata()    {        immutable(WitString)[$] authors = [            "You".witList        ];         return (immutable PluginMetadata(                name: "my-d-plugin".witList,                version_: "0.1.0".witList,                authors: authors.witList,                description: "An example plugin in D.".witList,                dependencies: WitList!WitString(),                permissions: WitList!WitString()        )).witClone;    }     @OnLoad    Result!(void, WitString) onLoad(Context ctx)    {        scope (exit)            ctx.witDrop; // Incoming resources must be cleaned up after use         log(Level.info, "Hello from D plugin!".witList);        return ok!WitString;    }} mixin RegisterPlugin!MyPlugin;

3. 3

   Building the plugin

   Compile the plugin into a WebAssembly component targeting wasm32-wasip2 with DUB:

   dub build -b release -a wasm32-wasip2

   my-d-plugin.wasm appears in the project root, ready to load into Pumpkin.

The full walkthrough is in the D documentation.

1. 1

   Setting up the project

   You will need Zig 0.16.0 or later and wasm-tools in your PATH.

   Fetch and add the pumpkin-api-zig package as a dependency:

   zig fetch --save git+https://github.com/Pumpkin-MC/pumpkin-api-zig

   Create a build.zig file in the root of your project:

   const std = @import("std");const pumpkin_api = @import("pumpkin_api_zig"); pub fn build(b: *std.Build) void {    _ = pumpkin_api.addPlugin(b, b.dependency("pumpkin_api_zig", .{}), .{        .name = "my-zig-plugin",        .root_source_file = b.path("src/main.zig"),    });}

2. 2

   Creating your first plugin

   Create your plugin source code in src/main.zig:

   const std = @import("std");const pumpkin = @import("pumpkin"); pub const std_options: std.Options = .{ .logFn = pumpkin.logFn }; const MyPlugin = struct {    pub const metadata: pumpkin.Metadata = .{        .name = "my-zig-plugin",        .version = "0.1.0",        .authors = &.{"You"},        .description = "An example plugin in Zig.",    };     pub const events = .{        .player_join_event = onJoin,    };     pub fn onLoad(_: pumpkin.Context) !void {        std.log.info("Hello from Zig!", .{});    }     fn onJoin(_: pumpkin.Server, ev: *pumpkin.EventData(.player_join_event)) void {        std.log.info("{s} joined", .{ev.player.getName()});    }}; comptime {    pumpkin.register(MyPlugin);}

3. 3

   Building the plugin

   Compile the plugin into a WebAssembly component:

   zig build

   This will produce zig-out/my-zig-plugin.wasm ready to be loaded into Pumpkin.

The full walkthrough is in the Zig documentation.

The full walkthrough is in the pumpkin-api-ts repository.