Generating Minecraft plugins (Spigot, Paper, Folia, proxies)

Codexe generates server-side plugins for the whole Bukkit family and for proxies. The target you pick changes the scaffold, the dependency set and the scheduling model the generated code uses.

• Bukkit / Spigot / Paper (Java) - the standard choice for single-server plugins.
• Bukkit / Spigot / Paper (Kotlin) - the same API surface with a Kotlin source set and Gradle build.
• Folia - Paper’s multithreaded fork, which requires region-aware scheduling.
• BungeeCord / Velocity - proxy plugins that sit in front of a network of backend servers.

A generated Java plugin is a complete Maven project (Kotlin targets use Gradle), not a single class. A typical tree looks like this:

my-plugin/
├── pom.xml
└── src/main/
    ├── java/com/example/myplugin/
    │   ├── MyPlugin.java          // JavaPlugin entry point
    │   ├── commands/HomeCommand.java
    │   └── listeners/JoinListener.java
    └── resources/
        ├── plugin.yml
        └── config.yml

The entry point extends JavaPlugin and wires up commands, listeners and configuration in onEnable(). Codexe compiles this on the platform, so you can confirm it builds before downloading.

plugin.yml is the descriptor Bukkit reads at load time. If it is missing or malformed the server refuses to load the plugin, which is the single most common cause of “my plugin does not appear”. Codexe always generates one:

name: MyPlugin
version: 1.0.0
main: com.example.myplugin.MyPlugin
api-version: '1.21'
commands:
  home:
    description: Teleport to your home
    usage: /home
    permission: myplugin.home
permissions:
  myplugin.home:
    default: true

• main must exactly match the fully-qualified class name. A rename that misses this line breaks the plugin.
• api-version tells the server which API generation the plugin was written against. Omitting it makes modern servers treat the plugin as legacy and remap materials.
• Commands declared here are the ones the server will route; a command handled in code but absent from the descriptor will never fire.

Spigot vs Paper

Paper is a fork of Spigot with a superset of the API. Code written for Spigot runs on Paper; the reverse is not true, because Paper adds methods and events Spigot does not have. If you need to support both, target Spigot.

Folia and regionised threading

Folia splits the world into independently ticking regions. The single main thread that ordinary Bukkit plugins assume does not exist, so Bukkit.getScheduler().runTask(...) is not valid. Work has to be scheduled against the right region or entity scheduler instead. Selecting the Folia target makes Codexe generate region-aware scheduling from the start rather than code that compiles and then throws at runtime.

BungeeCord and Velocity

Proxy plugins run in front of your servers, not inside them. They have no worlds, blocks or entities - the API is about players, connections and server routing. Use a proxy plugin for network-wide chat, queueing or transfers; use a Bukkit plugin for anything that touches gameplay.

Both compile to the same bytecode and use the same Bukkit API. Java is the safest default: every tutorial, most existing code and all server documentation assume it. Kotlin gives you null safety and much terser code, at the cost of shading the Kotlin standard library into your JAR.

Use the Spigot plugin generator for Java plugins, the Kotlin plugin generator for Kotlin, or the proxy plugin generator for BungeeCord and Velocity. If you want mods rather than plugins, see Forge and Fabric mods.