Reedwork - PaperMC Plugin Framework for Modern Java Plugins

Reedwork is a lightweight framework for building PaperMC plugins in Java with less boilerplate and a cleaner component architecture.

It provides dependency injection, annotation-based commands, automatic Bukkit and Paper event registration, Brigadier integration, custom enchantment registration, and reusable developer utilities.

Instead of manually connecting plugin components together, you define your commands, listeners, services, and other components. Reedwork discovers, creates, and registers them automatically.

Build Paper plugins with familiar Java and Paper APIs while removing repetitive infrastructure code.

Why use Reedwork for PaperMC plugin development?

Developing Minecraft plugins with Paper provides powerful APIs, but larger plugins often require additional infrastructure:

• commands need manual registration and argument handling
• event listeners need repeated registration code
• services need to be created and passed between classes
• components need lifecycle management
• custom registry features require Paper bootstrap integration

Reedwork provides a framework layer around these common tasks.

It does not replace Paper.

It helps organize and connect the code you already write.

With Reedwork, you can:

• create commands using Java annotations instead of manual Brigadier setup
• inject services using constructor-based dependency injection
• automatically register Bukkit and Paper event listeners
• define custom Minecraft enchantments as Java classes
• reuse utility components across your plugins

How Reedwork works

Reedwork is based on three core concepts:

1. Annotations describe plugin components.
2. Scanning discovers components automatically.
3. Resolution and registration connect components with Paper and with each other.

For example, an event listener remains a normal Bukkit/Paper listener:

@EventListener
public final class PlayerConnectionEvents implements Listener {

  @EventHandler
  public void onPlayerJoin(PlayerJoinEvent event) {
      // ...
  }
}

The @EventListener annotation tells Reedwork to discover and register the listener automatically.

Your code stays close to the Paper API.

Reedwork handles the infrastructure around it.

Features of the Paper plugin framework

Dependency injection for Paper plugins

Reedwork includes a dependency injection system designed for Minecraft plugin development.

Components can declare their dependencies directly in their constructors:

public ReedworkCommand(
      GreeterService greeterService,
      ExecuteCounter executeCounter
) {
  this.greeterService = greeterService;
  this.executeCounter = executeCounter;
}

Reedwork resolves these dependencies automatically when creating the component.

Supported features include:

• constructor injection
• singleton components
• transient components
• external class bindings
• factory-based bindings
• named dependency bindings

Learn more about Dependency Injection.

Annotation-based Paper commands

Reedwork simplifies Paper command development by generating command structures from Java classes and annotations.

Instead of manually creating Brigadier nodes and converting command arguments, define your command using normal Java types:

@SubCommand("<target>")
public boolean greetTarget(
      CommandContext context,
      Player target
) {
  return true;
}

The Java parameter type determines how Reedwork resolves the command argument.

Features include:

• Paper Brigadier integration;
• automatic argument resolution;
• command permissions;
• aliases;
• cooldowns;
• custom suggestions;
• generated usage information.

Learn more about Commands.

Automatic Bukkit and Paper event registration

Event handling stays compatible with the standard Bukkit and Paper API.

A listener only needs the Reedwork annotation:

@EventListener
public final class PlayerConnectionEvents implements Listener {

  @EventHandler
  public void onJoin(PlayerJoinEvent event) {
      // ...
  }
}

Reedwork discovers the listener during package scanning and registers it automatically.

Learn more about Events.

Custom Minecraft enchantments

Paper’s registry system allows plugins to create custom Minecraft content.

Reedwork simplifies custom enchantment registration by discovering CustomEnchantment implementations during the Paper bootstrap phase.

Example:

@Enchantment("reedworkpower")
public final class ReedworkEnchantment implements CustomEnchantment {
  // ...
}

Reedwork handles the registry integration while you define the enchantment behavior.

Learn more about Enchantments.

Built on top of Paper, not replacing it

Reedwork is designed to extend the Paper plugin development experience.

Your:

• Bukkit event listeners remain Bukkit event listeners
• Paper commands remain Paper Brigadier commands
• Java services remain normal Java classes
• enchantments remain integrated through Paper’s registry system

The framework only removes the repetitive infrastructure between these parts.

This makes Reedwork easy to adopt in existing Paper projects.

Who is Reedwork for?

Reedwork is useful for developers building:

• Minecraft Paper servers
• larger Java plugins
• multiplayer gameplay systems
• server management plugins
• plugins with many commands and services

It is especially useful when a plugin grows beyond a single main class and requires a structured component system.

Reedwork compared to manual Paper development

Without a framework, plugin developers often create their own solutions for:

• dependency management
• command registration
• listener registration
• service initialization
• component discovery

Reedwork provides these features as reusable infrastructure so developers can focus on plugin functionality instead of framework code.

Getting started with Reedwork

Start building your first PaperMC plugin with Reedwork:

1. Follow the Installation guide.
2. Create your first components.
3. Explore commands, events, dependency injection, and utilities.

Continue with:

• Installation
• Commands
• Events
• Dependency Injection
• Enchantments
• Utilities

Frequently asked questions

Is Reedwork a replacement for Paper?

No. Reedwork builds on top of Paper APIs and keeps the existing plugin development model.

Does Reedwork require a specific plugin architecture?

No. Reedwork works with regular Java classes and adds component discovery and registration features.

Does Reedwork replace Brigadier?

No. Reedwork integrates with Paper Brigadier and removes much of the manual command setup.

Can Reedwork be added to existing plugins?

Yes. Existing Paper plugins can adopt Reedwork incrementally by introducing Reedwork-managed components where useful.