A modern PaperMC plugin framework for Java.

Build PaperMC plugins with less boilerplate

Reedwork is a Java framework for building PaperMC plugins with less repetitive infrastructure code.

It provides dependency injection, annotation-based commands, automatic PaperMC event registration, Brigadier integration, automatic command parameter resolution, custom enchantment registration, and reusable utilities for Paper plugin development.

Instead of manually connecting commands, listeners, services, and other plugin components, Reedwork handles the infrastructure so you can focus on your plugin’s features and gameplay.

PaperMC plugin development features

Dependency Injection

Resolve constructor dependencies automatically across commands, event listeners, services, and other Reedwork components.

Annotation-Based Commands

Define Paper commands and subcommands with annotations instead of manually building and registering command structures.

Automatic Event Registration

Discover Bukkit and Paper event listeners automatically and register them during plugin startup.

Custom Enchantments

Define custom Minecraft enchantments as Java classes and register them through Paper’s registry lifecycle.

Brigadier Integration

Build Paper Brigadier commands with Java classes, annotations, and strongly typed command parameters.

Automatic Parameter Resolution

Map Java method parameters to supported Paper command arguments and receive resolved values directly in command handlers.

Custom Suggestions

Add application-specific command suggestions using suggestion providers and Reedwork’s dependency injection system.

Automatic Usage Generation

Generate command usage information automatically from the structure of your registered commands.

Developer Utilities

Reuse utilities for common Bukkit and Paper plugin development tasks instead of rebuilding them for every plugin.

Why use Reedwork for Paper plugins?

Paper provides a powerful API for Minecraft server development, but plugin infrastructure can still involve repetitive setup and registration code.

Reedwork provides a framework around the APIs you already use. Components are defined as normal Java classes, dependencies are expressed through constructors, and annotations describe components that Reedwork should discover and register.

This gives you a simpler development model without replacing the underlying Paper APIs.

Less infrastructure code

Reedwork takes care of repetitive component discovery, dependency wiring, command registration, and event registration.

Your plugin code can concentrate on application logic instead of infrastructure.

Familiar Java and Paper APIs

Reedwork does not require a separate programming model.

Your services remain Java classes.

Your event listeners remain Bukkit or Paper listeners.

Your commands are integrated with Paper’s command system.

Your registry-backed components use Paper’s lifecycle and registry APIs.

Designed for modular plugins

Dependency injection makes it easier to separate commands, services, listeners, and other components into focused classes.

Instead of creating and passing every dependency manually, components declare what they need through their constructors.

See a Paper command in action

A Reedwork command is a normal Java class annotated with @Command.

@Command("hello")
public final class HelloCommand {

    @CommandHandler
    public boolean execute(CommandContext context) {
        context.player().sendMessage(
            Component.text("Hello, Reedwork!")
        );

        return true;
    }
}

Reedwork discovers the command during component scanning and registers it with the appropriate Paper command infrastructure.

Command metadata such as descriptions, permissions, cooldowns, aliases, and usage can be configured when required.

Usage information can also be generated automatically from the registered command structure.

Learn more about the Reedwork command system.

Dependency injection for Paper plugins

Reedwork uses constructor-based dependency injection to connect plugin components.

@Command("hello")
public final class HelloCommand {

    private final GreeterService greeterService;

    public HelloCommand(GreeterService greeterService) {
        this.greeterService = greeterService;
    }

    @CommandHandler
    public boolean execute(CommandContext context) {
        greeterService.sendGreeting(context.player());
        return true;
    }
}

The command does not need to create or locate GreeterService.

Reedwork resolves the constructor dependency and provides the required component when the command is created.

This keeps dependencies explicit and avoids service locators or large amounts of manual wiring.

Reedwork supports singleton and transient component lifecycles as well as explicit bindings for external classes.

Read the dependency injection documentation to learn how component resolution works.

Commands, events, and enchantments

Reedwork focuses on common areas of Paper plugin development where repetitive infrastructure can otherwise accumulate.

Annotation-based commands

Define commands and subcommands using Java classes and annotations while Reedwork builds the underlying command structure.

Supported Java parameters can be resolved automatically, allowing command handlers to work with typed values instead of parsing raw command input.

Explore annotation-based commands and Brigadier integration.

Automatic event registration

Write regular Bukkit or Paper event listeners and mark them for Reedwork discovery.

Reedwork scans your plugin components and registers supported listeners automatically.

See automatic event registration.

Custom enchantments

Define custom Minecraft enchantments as Java components and let Reedwork integrate them with Paper’s registry lifecycle.

Learn more about custom enchantments.

How Reedwork works

Reedwork follows a simple three-stage process for building your plugin infrastructure.

1. Discover

   Reedwork scans your plugin package and discovers supported components such as commands, event listeners, services, and other annotated classes.

2. Resolve

   Reedwork resolves constructor dependencies through its dependency injection system.

   Components declare what they need, while Reedwork creates and connects the required objects.

3. Register

   Reedwork connects discovered components to the appropriate Paper systems.

   Commands are integrated with Paper’s command infrastructure, event listeners are registered with Bukkit or Paper, and registry-backed components are created during the appropriate Paper lifecycle phase.

Built on Paper

Reedwork complements Paper rather than replacing it.

Your plugin continues to use the APIs provided by Paper and Bukkit:

• commands use Paper’s command infrastructure
• event listeners use Bukkit and Paper events
• registry-backed components use Paper’s registry and lifecycle APIs
• services remain ordinary Java classes
• plugin logic remains under your control

The framework removes repetitive infrastructure without forcing your plugin into a large framework-specific architecture.

Keep your plugin architecture simple

Reedwork is intentionally focused on infrastructure.

You define Java classes that represent the actual responsibilities of your plugin and describe their dependencies through constructors and annotations.

Reedwork handles component discovery, dependency resolution, and registration.

You define what your plugin needs. Reedwork handles how those components are connected.

This makes it possible to introduce the framework incrementally while keeping your code close to the Paper programming model.

What can you build with Reedwork?

Reedwork is useful when your Paper plugin needs:

• constructor-based dependency injection
• annotation-based commands and subcommands
• Paper Brigadier integration
• automatic command parameter resolution
• custom command suggestions
• automatic PaperMC event registration
• custom Minecraft enchantment registration
• reusable developer utilities
• modular Java services with explicit dependencies

The goal is not to hide Paper from you.

The goal is to remove the repetitive infrastructure that surrounds your Paper plugin code.

Start building your PaperMC plugin

Start with the Reedwork introduction to understand the framework and its core concepts.

Then follow the installation guide and continue with the quick start to build your first plugin.

Get started with Reedwork View Reedwork on GitHub

Explore Reedwork

Continue exploring the framework through the main feature areas:

• Commands and Brigadier integration
• Dependency injection
• Automatic event registration
• Custom enchantments
• Developer utilities