Pumpkin

https://docs.pumpkinmc.org
Admin
Pumpkin is a high-performance Minecraft server implementation written in Rust that supports Wasm...
Tokens:90,412
Snippets:844
Trust Score:6.4
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start Pumpkin server

Source: https://docs.pumpkinmc.org/plugin-dev/d/quick-start

Starts or restarts the Pumpkin server to load the plugin.

```bash
./pumpkin
```

--------------------------------

### Docker run example

Source: https://docs.pumpkinmc.org/

Example command to run Pumpkin on port 25565 with data stored in the ./data directory.

```shell
docker run --rm \
    -p 25565:25565 \
    -v ./data:/pumpkin \
    -it ghcr.io/pumpkin-mc/pumpkin:master
```

--------------------------------

### Complete Plugin Implementation

Source: https://docs.pumpkinmc.org/plugin-dev/rust/plugin-utils

A full implementation example in src/lib.rs demonstrating initialization, online licensing checks, offline grace periods, and update checking.

```rust
use pumpkin_plugin_api::{Context, Plugin, PluginMetadata};
use pumpkin_plugin_utils::LicenseStatus;
use tracing::{error, info, warn};

struct CommercialPlugin;

impl Plugin for CommercialPlugin {
    fn new() -> Self {
        Self
    }

    fn metadata(&self) -> PluginMetadata {
        PluginMetadata {
            name: "CommercialPlugin".into(),
            version: env!("CARGO_PKG_VERSION").into(),
            authors: vec!["Developer".into()],
            description: "A commercial Pumpkin plugin".into(),
        }
    }

    fn on_load(&mut self, context: Context) -> pumpkin_plugin_api::Result<()> {
        // 1. Initialize plugin-utils (verifies Ed25519 signature & caches metadata)
        let meta = pumpkin_plugin_utils::init(&context).map_err(|err| {
            error!("Signature verification failed: {err}");
            format!("Security verification error: {err}")
        })?;

        info!("Loaded {} v{}", meta.plugin_name, meta.version);

        // 2. Validate license (offline evaluation + online check)
        match pumpkin_plugin_utils::evaluate_license(7) {
            LicenseStatus::Valid(_) => {
                info!("Local license status: Valid");
            }
            LicenseStatus::GracePeriod { days_remaining, .. } => {
                warn!("Local license in grace period: {days_remaining} days remaining");
            }
            LicenseStatus::Unsigned => {
                info!("Running in development mode (unsigned binary)");
            }
            LicenseStatus::Invalid(reason) => {
                error!("Invalid license: {reason}");
                return Err(format!("License verification failed: {reason}").into());
            }
        }

        // 3. Online license check if paid
        if meta.is_paid {
            if let Ok(check) = pumpkin_plugin_utils::check_license_online(None) {
                if !check.valid {
                    return Err(format!("Online license rejected: {}", check.status).into());
                }
                info!("Online license check confirmed: {}", check.status);
            } else {
                warn!("Online license verification unreachable, falling back to local lease");
            }
        }

        // 4. Check for updates
        if let Ok(update) = pumpkin_plugin_utils::check_for_updates() {
            if update.update_available {
                info!(
                    "A new version is available on the marketplace: {}",
                    update.latest_version.as_deref().unwrap_or("unknown")
                );
            }
        }

        Ok(())
    }

    fn on_unload(&mut self, _context: Context) -> pumpkin_plugin_api::Result<()> {
        info!("CommercialPlugin unloaded.");
        Ok(())
    }
}

pumpkin_plugin_api::register_plugin!(CommercialPlugin);
```

--------------------------------

### Install pumpkin-api-py

Source: https://docs.pumpkinmc.org/plugin-dev/python/quick-start

Install the Python library required for plugin development.

```bash
pip install pumpkin-api-py
```

--------------------------------

### Complete Go plugin main.go

Source: https://docs.pumpkinmc.org/plugin-dev/go/first-command

A full example of a Go plugin file that registers a /hello command, defines permissions, and handles command execution.

```go
package main

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/api"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_command"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_context"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_permission"
	_ "github.com/Pumpkin-MC/pumpkin-api-go/pkg/wit_exports"
)

type MyPlugin struct {
	api.DefaultPlugin
}

func (p *MyPlugin) Metadata() api.Metadata {
	return api.Metadata{
		Name:        "my_go_plugin",
		Version:     "0.1.0",
		Authors:     []string{"Developer"},
		Description: "My first Pumpkin Go plugin",
	}
}

func (p *MyPlugin) OnLoad(ctx *pumpkin_plugin_context.Context) {
	// 1. Register permission node
	ctx.RegisterPermission(pumpkin_plugin_permission.Permission{
		Node:        "my_go_plugin:hello",
		Description: "Allows executing the /hello command",
		Default:     pumpkin_plugin_permission.PermissionDefaultAllow(),
	})

	// 2. Build and register command tree
	cmd := pumpkin_plugin_command.New([]string{"hello", "hi"}, "Greets the player")
	ctx.RegisterCommand(cmd, "my_go_plugin:hello")
}

func (p *MyPlugin) HandleCommand(cmdID uint32, sender pumpkin_plugin_command.CommandSender) int32 {
	sender.SendMessage("Hello from Go Plugin!")
	return 1
}

func init() {
	api.RegisterPlugin(&MyPlugin{})
}

func main() {}
```

--------------------------------

### Create MyPlugin.cs

Source: https://docs.pumpkinmc.org/plugin-dev/csharp/quick-start

Replace the content of Class1.cs or create MyPlugin.cs with this example plugin implementation. It implements the required interfaces and provides metadata.

```csharp
using PluginWorld;
using PluginWorld.wit.Exports.pumpkin.plugin.v0_1_0;
using PluginWorld.wit.Imports.pumpkin.plugin.v0_1_0;

namespace MyPumpkinPlugin;

public class MyPlugin : IPluginWorldExports, IMetadataExports
{
    public static void InitPlugin() { }

    public static void OnLoad(IContextImports.Context context)
    {
        ILoggingImports.Log(ILoggingImports.Level.Info, "C# plugin loaded!");
    }

    public static void OnUnload(IContextImports.Context context) { }

    public static IEventImports.Event HandleEvent(uint eventId, IServerImports.Server server, IEventImports.Event @event)
    {
        return @event;
    }

    public static int HandleCommand(uint commandId, ICommandImports.CommandSender sender, IServerImports.Server server, ICommandImports.ConsumedArgs args)
    {
        return 0;
    }

    public static void HandleTask(uint handlerId, IServerImports.Server server) { }

    public static IMetadataExports.PluginMetadata Metadata()
    {
        return new IMetadataExports.PluginMetadata(
            "my-csharp-plugin",
            "0.1.0",
            "An example C# plugin.",
            ["YourName"],
            []
        );
    }
}
```

--------------------------------

### Install fish shell and set as default

Source: https://docs.pumpkinmc.org/developer/mobile

Installs the fish shell and changes the default shell to fish, recommended for a more friendly command-line experience.

```bash
pkg install fish
chsh -s fish
```

--------------------------------

### Complete C Plugin Example (main.c)

Source: https://docs.pumpkinmc.org/plugin-dev/c/first-command

Complete C plugin file (main.c) that registers a /hello command with permission checks and sends a response back to the player. It defines plugin_on_load, plugin_handle_command, and plugin_get_metadata functions.

```c
#include <stdio.h>
#include "pumpkin.h"

void plugin_on_load(pumpkin_context_t ctx) {
    // 1. Register permission node
    pumpkin_permission_t perm = {
        .node = "my_c_plugin:hello",
        .description = "Allows executing the /hello command",
        .default_access = PERMISSION_DEFAULT_ALLOW
    };
    pumpkin_register_permission(ctx, &perm);

    // 2. Build and register command tree
    const char* names[] = {"hello", "hi"};
    pumpkin_command_t cmd = pumpkin_command_new(names, 2, "Greets the player");
    
    pumpkin_register_command(ctx, cmd, "my_c_plugin:hello");
}

int32_t plugin_handle_command(uint32_t command_id, pumpkin_sender_t sender, pumpkin_server_t server) {
    pumpkin_sender_send_message(sender, "Hello from C Plugin!");
    return 1;
}

pumpkin_metadata_t plugin_get_metadata() {
    pumpkin_metadata_t meta = {
        .name = "my_c_plugin",
        .version = "0.1.0",
        .description = "My first Pumpkin C plugin"
    };
    return meta;
}
```

--------------------------------

### Registering a Kotlin Plugin Command

Source: https://docs.pumpkinmc.org/plugin-dev/kotlin/first-command

A complete example of a Kotlin plugin class that registers a /hello command with permission checks and a response handler.

```kotlin
package plugin

import pumpkin.plugin.context.Context
import pumpkin.plugin.command.Command
import pumpkin.plugin.permission.Permission
import pumpkin.plugin.permission.PermissionDefault

class MyPlugin {
    fun onLoad(ctx: Context) {
        // 1. Register permission node
        ctx.registerPermission(
            Permission(
                node = "my_kotlin_plugin:hello",
                description = "Allows executing the /hello command",
                default = PermissionDefault.ALLOW,
                children = emptyList()
            )
        )

        // 2. Build and register command tree
        val cmd = Command(
            names = listOf("hello", "hi"),
            description = "Greets the player"
        )
        ctx.registerCommand(cmd, "my_kotlin_plugin:hello")
    }

    fun handleCommand(sender: pumpkin.plugin.command.CommandSender): Int {
        sender.sendMessage("Hello from Kotlin Plugin!")
        return 1
    }
}
```

--------------------------------

### Complete MyPlugin.cs Command Registration

Source: https://docs.pumpkinmc.org/plugin-dev/csharp/first-command

A full example of a C# plugin file that registers a /hello command, defines a permission node, and handles the command execution.

```csharp
using PluginWorld;
using PluginWorld.wit.Exports.pumpkin.plugin.v0_1_0;
using PluginWorld.wit.Imports.pumpkin.plugin.v0_1_0;

namespace MyPumpkinPlugin;

public class MyPlugin : IPluginWorldExports, IMetadataExports
{
    public static void InitPlugin() { }

    public static void OnLoad(IContextImports.Context context)
    {
        // 1. Register permission node
        var perm = new IPermissionImports.Permission(
            "my_csharp_plugin:hello",
            "Allows executing the /hello command",
            IPermissionImports.PermissionDefault.Allow,
            []
        );
        IContextImports.RegisterPermission(context, perm);

        // 2. Build and register command tree
        var command = ICommandImports.Command.New(["hello", "hi"], "Greets the player");
        IContextImports.RegisterCommand(context, command, "my_csharp_plugin:hello");
    }

    public static void OnUnload(IContextImports.Context context) { }

    public static IEventImports.Event HandleEvent(uint eventId, IServerImports.Server server, IEventImports.Event @event)
    {
        return @event;
    }

    public static int HandleCommand(uint commandId, ICommandImports.CommandSender sender, IServerImports.Server server, ICommandImports.ConsumedArgs args)
    {
        ICommandImports.SendMessage(sender, "Hello from C# Plugin!");
        return 1;
    }

    public static void HandleTask(uint handlerId, IServerImports.Server server) { }

    public static IMetadataExports.PluginMetadata Metadata()
    {
        return new IMetadataExports.PluginMetadata(
            "my_csharp_plugin",
            "0.1.0",
            "My first Pumpkin C# plugin",
            ["Developer"],
            []
        );
    }
}
```

--------------------------------

### Install essential packages with pkg

Source: https://docs.pumpkinmc.org/developer/mobile

Updates package lists and installs build tools, Git, Rust, rust-analyzer, taplo, Helix, and Node.js in Termux.

```bash
pkg update && pkg upgrade
pkg install build-essential git rust rust-analyzer taplo helix helix-grammar nodejs
```

--------------------------------

### Pumpkin startup commands for Linux/macOS, Windows, and Docker

Source: https://docs.pumpkinmc.org/admin/migrating-from-bukkit

Commands to start a Pumpkin server on different platforms. Linux/macOS uses ./pumpkin, Windows uses ./pumpkin.exe, and Docker uses the pumpkinmc/pumpkin image with port and volume mapping.

```bash
# Linux / macOS:
./pumpkin

# Windows:
./pumpkin.exe

# Docker:
docker run -p 25565:25565 -v ./data:/data pumpkinmc/pumpkin:latest
```

--------------------------------

### Install GitHub CLI with pkg

Source: https://docs.pumpkinmc.org/developer/mobile

Installs the GitHub CLI (gh) package, required for contributing to the project.

```bash
pkg install gh
```

--------------------------------

### pumpkin.toml plugin configuration with global settings and per-plugin overrides

Source: https://docs.pumpkinmc.org/config/plugins

Defines the [plugins] section in pumpkin.toml with all global plugin settings and an example [plugins.overrides.my_plugin] block that shows per-plugin permission, memory, network, and environment overrides. The example setting allow_unsigned = true and verify_signatures = true must be adjusted if strict signature enforcement is desired.

```toml
[plugins]
enabled = true
hot_reload = false
ask_permission_confirmation = true
allow_unsigned = true
allowed_permissions = []
blocked_permissions = []
inherit_env = false
loopback_only = false
verify_signatures = true

# Optional per-plugin overrides
[plugins.overrides.my_plugin]
enabled = true
allow_unsigned = true
max_memory_mb = 128
allowed_permissions = ["fs:read:data"]
blocked_permissions = ["network:outbound"]
loopback_only = true

[plugins.overrides.my_plugin.environment]
API_KEY = "example_secret"
```

--------------------------------

### pumpkin.toml commands configuration

Source: https://docs.pumpkinmc.org/config/commands

Example configuration for the [commands] section in pumpkin.toml, showing console/TTY settings, logging, broadcasting, default op level, and per-command overrides for gamemode and tp.

```toml
[commands]
use_console = true
use_tty = true
log_console = true
broadcast_console_to_ops = true
default_op_level = 0

# Optional per-command overrides
[commands.overrides.gamemode]
permission_level = 4

[commands.overrides.tp]
enabled = false

```

--------------------------------

### Common Paper startup command with Aikar's Flags

Source: https://docs.pumpkinmc.org/admin/migrating-from-bukkit

Java command for starting a Paper server with Aikar's flags for garbage collection tuning. These JVM flags do not apply to Pumpkin and should be removed when migrating.

```bash
java -Xms10G -Xmx10G \
  -XX:+UseG1GC \
  -XX:+ParallelRefProcEnabled \
  -XX:MaxGCPauseMillis=200 \
  -XX:+UnlockExperimentalVMOptions \
  -XX:+DisableExplicitGC \
  -XX:+AlwaysPreTouch \
  -XX:G1NewSizePercent=30 \
  -XX:G1MaxNewSizePercent=40 \
  -XX:G1HeapRegionSize=8M \
  -XX:G1ReservePercent=20 \
  -XX:G1HeapWastePercent=5 \
  -XX:G1MixedGCCountTarget=4 \
  -XX:InitiatingHeapOccupancyPercent=15 \
  -XX:G1MixedGCLiveThresholdPercent=90 \
  -XX:G1RSetUpdatingPauseTimePercent=5 \
  -XX:SurvivorRatio=32 \
  -XX:+PerfDisableSharedMem \
  -XX:MaxTenuringThreshold=1 \
  -Dusing.aikars.flags=https://mcflags.emc.gs \
  -Daikars.new.flags=true \
  -jar paper.jar --nogui
```

--------------------------------

### Go plugin entry point (main.go)

Source: https://docs.pumpkinmc.org/plugin-dev/go/basic-logic

Implement the api.Plugin interface, register in init(), and import wit_exports for WebAssembly compatibility.

```go
package main

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/api"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_context"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_logging"
	_ "github.com/Pumpkin-MC/pumpkin-api-go/pkg/wit_exports" // Required for WASM exports
)

type MyPlugin struct {
	api.DefaultPlugin
}

func (p *MyPlugin) Metadata() api.Metadata {
	return api.Metadata{
		Name:    "my-go-plugin",
		Version: "0.1.0",
		Authors: []string{"you"},
	}
}

func (p *MyPlugin) OnLoad(ctx *pumpkin_plugin_context.Context) {
	pumpkin_plugin_logging.Log(pumpkin_plugin_logging.LevelInfo(), "Go plugin loaded!")
}

func init() {
	api.RegisterPlugin(&MyPlugin{})
}

func main() {}
```

--------------------------------

### Fuels Extractor Implementation

Source: https://docs.pumpkinmc.org/developer/extractor

Example extractor that queries vanilla fuel values and writes them to a JSON file. Uses `server.fuelValues()` to get fuel items and burn durations.

```kotlin
package de.snowii.extractor.extractors

import com.google.gson.JsonElement
import com.google.gson.JsonObject
import com.google.gson.JsonPrimitive
import de.snowii.extractor.Extractor
import net.minecraft.core.registries.BuiltInRegistries
import net.minecraft.server.MinecraftServer
import net.minecraft.world.item.Item
import net.minecraft.world.item.ItemStack

class Fuels : Extractor.Extractor {
    override fun fileName(): String {
        return "fuels.json"
    }

    override fun extract(server: MinecraftServer): JsonElement {
        val fuelsJson = JsonObject()

        // Query vanilla runtime methods
        server.fuelValues().fuelItems().forEach { fuel ->
            val itemId = BuiltInRegistries.ITEM.getKey(fuel).toString()
            val burnDuration = server.fuelValues().burnDuration(ItemStack(fuel))
            fuelsJson.add(itemId, JsonPrimitive(burnDuration))
        }

        return fuelsJson
    }
}
```

--------------------------------

### Install wasm32-wasip2 target

Source: https://docs.pumpkinmc.org/plugin-dev/rust/creating-project

Run this command to install the WebAssembly target required for compiling Pumpkin plugins.

```bash
rustup target add wasm32-wasip2
```

--------------------------------

### Initialize a Go module for a Pumpkin plugin

Source: https://docs.pumpkinmc.org/plugin-dev/go/quick-start

Creates a new directory for the plugin project, navigates into it, and initializes a Go module with the module path github.com/yourname/hello-pumpkin.

```bash
mkdir hello-pumpkin
cd hello-pumpkin
go mod init github.com/yourname/hello-pumpkin
```

--------------------------------

### Building the Command Tree

Source: https://docs.pumpkinmc.org/plugin-dev/kotlin/first-command

Instantiate Command with primary names and aliases.

```kotlin
val cmd = Command(
    names = listOf("hello", "hi"),
    description = "Greets the player"
)
```

--------------------------------

### Install WASI workload

Source: https://docs.pumpkinmc.org/plugin-dev/csharp/quick-start

Install the WebAssembly System Interface (WASI) workload for .NET, which is required for building WebAssembly components.

```bash
dotnet workload install wasi-experimental
```

--------------------------------

### Create main.c plugin file

Source: https://docs.pumpkinmc.org/plugin-dev/c/quick-start

Define the plugin metadata and the on_load callback in main.c.

```c
#include "pumpkin_api.h"
#include <stdio.h>

pumpkin_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
    };
}

void on_load(plugin_own_context_t ctx) {
    printf("C plugin loaded!\n");
}

REGISTER_PUMPKIN_PLUGIN(((pumpkin_plugin_t){
    .get_metadata = get_meta,
    .on_load = on_load
}))
```

--------------------------------

### CommandSyntaxError Visual Pointer Example

Source: https://docs.pumpkinmc.org/developer/commands

An example of how the dispatcher formats a visual pointer to highlight syntax errors in a command string.

```text
Unknown or incomplete command, see below for error
/gamemode creatve<--[HERE]
```

--------------------------------

### Create new class library project

Source: https://docs.pumpkinmc.org/plugin-dev/csharp/quick-start

Create a new class library project named MyPumpkinPlugin and navigate into its directory.

```bash
dotnet new classlib -n MyPumpkinPlugin
cd MyPumpkinPlugin
```

--------------------------------

### Define custom server links in [server_links.custom]

Source: https://docs.pumpkinmc.org/config/server-links

Shows how to define arbitrary key-value links that appear in client menus. Replace the placeholder URLs with your actual links.

```toml
[server_links.custom]
"Store" = "https://store.example.com"
"Discord" = "https://discord.gg/example"

```

--------------------------------

### Install recommended Cargo tools

Source: https://docs.pumpkinmc.org/developer/contributing

Commands to install cargo-nextest (fast unit test runner), cargo-machete (detects unused dependencies), and typos-cli (source code spell checker).

```bash
# Fast unit test runner used in CI
cargo install cargo-nextest --locked

# Detects unused dependencies
cargo install cargo-machete --locked

# Source code spell checker
cargo install typos-cli --locked
```

--------------------------------

### Add rand crate

Source: https://docs.pumpkinmc.org/plugin-dev/rust/command/rock-paper-scissors

Installs the rand crate, required for generating random choices.

```bash
cargo add rand

```

--------------------------------

### Run Pumpkin via Nix

Source: https://docs.pumpkinmc.org/

Execute Pumpkin directly from nixpkgs without a permanent installation.

```shell
nix run nixpkgs#pumpkin-mc
```

--------------------------------

### Create a Feature Branch

Source: https://docs.pumpkinmc.org/developer/contributing

Use this command to create and switch to a new feature branch before starting your work.

```bash
git checkout -b feature/my-new-feature
```

--------------------------------

### Create project directory

Source: https://docs.pumpkinmc.org/plugin-dev/d/quick-start

Creates a new directory for the D plugin project and navigates into it.

```bash
mkdir my-d-plugin
cd my-d-plugin
```

--------------------------------

### Clone the Pumpkin Kotlin Plugin Template

Source: https://docs.pumpkinmc.org/plugin-dev/kotlin/quick-start

Clone the template repository and rename the directory to start your project.

```sh
git clone --recurse-submodules https://github.com/Pumpkin-MC/pumpkin-api-kt
mv pumpkin-api-kt my_kotlin_plugin
cd my_kotlin_plugin
```

--------------------------------

### Register and execute command

Source: https://docs.pumpkinmc.org/plugin-dev/go/first-command

Register the command with ctx.RegisterCommand and handle execution in HandleCommand.

```go
ctx.RegisterCommand(cmd, "my_go_plugin:hello")
```

--------------------------------

### Executing the Rock Paper Scissors command

Source: https://docs.pumpkinmc.org/plugin-dev/rust/command/rock-paper-scissors

Example of the command syntax used in-game to play the game.

```bash
/rps rock
```

--------------------------------

### Run Pumpkin from source

Source: https://docs.pumpkinmc.org/

Execute the server using cargo. Note that release builds may take time due to optimizations.

```shell
cargo run --release
```

--------------------------------

### Run Pumpkin with Docker

Source: https://docs.pumpkinmc.org/

Start the Pumpkin server using Docker with port mapping and volume mounting for data persistence.

```shell
docker run --rm \
    -p <exposed_port>:25565  \
    -v <server_data_location>:/pumpkin \
    -it ghcr.io/pumpkin-mc/pumpkin:master
```

--------------------------------

### Unsafe Code Documentation

Source: https://docs.pumpkinmc.org/developer/contributing

Example of the required safety comment block that must precede any unsafe code to pass CI lints.

```rust
// SAFETY: The buffer is guaranteed to contain at least 4 valid bytes
// as verified by the bounds check on line 42.
unsafe {
    // ...
}
```

--------------------------------

### Build the command tree

Source: https://docs.pumpkinmc.org/plugin-dev/go/first-command

Instantiate the command tree using pumpkin_plugin_command.New.

```go
cmd := pumpkin_plugin_command.New([]string{"hello", "hi"}, "Greets the player")
```

--------------------------------

### Bukkit Implementation of a Custom Menu GUI

Source: https://docs.pumpkinmc.org/plugin-dev/migrating-from-bukkit/inventories

Demonstrates creating a 9-slot inventory and handling clicks using Bukkit's InventoryClickEvent.

```java
public class MenuGUI implements Listener {

    public void openMenu(Player player) {
        Inventory inv = Bukkit.createInventory(null, 9, Component.text("Custom Menu"));

        ItemStack item = new ItemStack(Material.DIAMOND);
        ItemMeta meta = item.getItemMeta();
        meta.displayName(Component.text("Click Me!"));
        item.setItemMeta(meta);

        inv.setItem(4, item);
        player.openInventory(inv);
    }

    @EventHandler
    public void onInventoryClick(InventoryClickEvent event) {
        if (event.getView().getTitle().equals("Custom Menu")) {
            event.setCancelled(true);
            if (event.getSlot() == 4) {
                event.getWhoClicked().sendMessage("Diamond clicked!");
            }
        }
    }
}
```

--------------------------------

### Build the Plugin

Source: https://docs.pumpkinmc.org/plugin-dev/kotlin/quick-start

Build the plugin into a WebAssembly component using the Makefile.

```sh
make
```

--------------------------------

### Project folder structure

Source: https://docs.pumpkinmc.org/plugin-dev/rust/creating-project

Shows the expected folder structure after creating the crate and adding the .cargo/config.toml file.

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

--------------------------------

### send_feedback example

Source: https://docs.pumpkinmc.org/developer/commands/execution-and-context

Sends feedback to the command sender, with a boolean flag to broadcast to server operators. Output behavior is governed by game rules and the silent flag.

```rust
context.source.send_feedback(
    TextComponent::text("Command executed successfully!"),
    true, // Broadcast to server operators
);
```

--------------------------------

### Build command tree with aliases and executor

Source: https://docs.pumpkinmc.org/plugin-dev/python/first-command

Creates a command.Command instance with primary names and aliases, then attaches the handler using .execute(...). This is Step 2 in the command creation process.

```python
cmd = command.Command(["hello", "hi"], "Greets the player")
cmd.execute(HelloCommand())
```

--------------------------------

### pumpkin.toml [world] configuration

Source: https://docs.pumpkinmc.org/config/world

Example configuration for world settings, including lighting mode, autosave ticks, chunk storage type, write-in-place, and compression settings.

```toml
[world]
lighting = "default"
autosave_ticks = 6000

[world.chunk]
type = "anvil"
write_in_place = false

[world.chunk.compression]
algorithm = "LZ4"
level = 6

```
Tokens:
Raw