Paper vs Spigot vs Purpur: Which Server Should You Choose?

Paper builds on the Spigot ecosystem with its own API and optimizations. Purpur builds on Paper with a large optional configuration layer. Spigot remains an important foundation, but starting directly on it usually gives a new administrator fewer tools without a clear compensating benefit.

This comparison uses the projects’ public documentation as reviewed on August 10, 2026. It avoids synthetic benchmarks because results depend on the world, plugins, players, hardware and configuration.

Paper vs Spigot vs Purpur at a glance

Question	Spigot	Paper	Purpur
Best fit	Conservative Spigot baseline or an explicit support requirement	Most new general-purpose plugin servers	Paper servers that need extra configurable gameplay features
Project lineage	Fork of CraftBukkit	Based on Spigot	Drop-in replacement for Paper
Plugin reach	Bukkit and Spigot plugins	Most Bukkit/Spigot plugins, plus Paper-only plugins	CraftBukkit, Spigot and Paper plugins in normal cases
Configuration surface	server.properties, Bukkit and Spigot settings	Spigot settings plus Paper global/per-world settings	Paper settings plus purpur.yml
Performance position	Adds optimizations over CraftBukkit	Adds further server and API optimizations	Inherits Paper and adds Purpur’s own changes
Safest default for a new server	Only with a reason to prefer it	Yes	If you already know which Purpur features you want
Vanilla fidelity	Not identical to Vanilla	Not 100% Vanilla-compatible	Paper behavior by default, with more optional changes

These projects share a lineage, so moving upward usually broadens the API and configuration surface. That does not guarantee plugin compatibility, better performance from every setting or a safe move backward.

What Spigot is good at

Spigot is a CraftBukkit fork with additional features and optimizations. Its strengths are its established community, API and resource ecosystem. The Spigot installation guide describes it as a drop-in CraftBukkit replacement.

Spigot is a reasonable choice when:

• a commercial plugin vendor says it supports Spigot but not Paper forks;
• you are reproducing a bug against the platform a plugin author officially supports;
• an established host or operations process is standardized on Spigot.

Its setup process is less direct than Paper’s. Spigot distributes current server builds through BuildTools, which downloads the required sources and builds the server JAR locally. Paper and Purpur publish runnable JAR files from their own download services.

Spigot exposes meaningful controls through spigot.yml; its configuration reference covers global and per-world behavior. Paper retains those inherited settings while adding its own, so “simpler” means a smaller surface, not necessarily easier administration.

For a new server, choose Spigot only for a specific constraint.

Why Paper is the best default for most servers

Paper describes itself as a Minecraft server based on Spigot with additional performance work, advanced features and an expanded API. Its documented optimizations include areas such as chunk loading, lighting, hoppers and entities. Those are project claims, not a promise that Paper will fix every lag problem.

Paper is the strongest default because it balances:

1. Broad plugin compatibility. Conventional Bukkit and Spigot plugins normally run on Paper. Paper-only plugins can use APIs unavailable on Spigot, as its plugin documentation explains.
2. Useful administration tooling. Paper documents configuration, troubleshooting, profiling and updates in one place. Its built-in Spark profiler is a better starting point than guessing when a server slows down.
3. Sensible defaults. Paper says it is optimized without a copied “ultimate settings” file. Aggressive presets can change spawning, farms and redstone while hiding the real problem.
4. A clear support path. Paper maintains administrator documentation, a support community and Hangar, its plugin repository.

Paper is still not Vanilla. The project’s Vanilla-like configuration guide says a 100% Vanilla experience is not currently possible, and its bug-fix documentation explains that some duplication exploits and other behaviors are changed. If your group builds technical redstone machines that depend on exact Vanilla quirks, test those machines before committing your only world to Paper.

Paper is not a mod loader. It runs plugins, not Fabric, Forge or NeoForge mods. If you are deciding whether friends need mods or server-side plugins, use our plugins vs mods guide rather than trying a hybrid JAR.

When Purpur is the better choice

Purpur’s official documentation describes it as a drop-in Paper replacement focused on configurability and optional gameplay features. It inherits Paper, Spigot and Bukkit APIs. Purpur’s FAQ says CraftBukkit, Spigot and Paper plugins normally work, with exceptions such as plugins that hard-code a particular server implementation.

Purpur becomes compelling when its configuration is the reason you chose it. Its purpur.yml covers gameplay mechanics, entity behavior, commands and presentation that might otherwise require plugins. Verify each option in the Purpur configuration reference before enabling it.

Use Purpur when:

• you can point to one or more Purpur settings that replace a plugin or custom patch you would otherwise maintain;
• you want to experiment with configurable entity or gameplay behavior;
• you are comfortable testing changes on a staging copy of the world;
• your important plugins list Paper or Purpur as supported platforms.

Do not choose Purpur merely because “more settings” sounds faster. Purpur inherits Paper’s performance work, but its distinguishing value is control. Each optional behavior increases the number of things you may need to remember during troubleshooting. Purpur says its added changes retain Paper-like defaults until you enable them, so a fresh Purpur server should be treated as Paper with an unused control panel—not as an automatic performance upgrade.

Purpur is a good second step: begin with Paper and move when a documented Purpur option solves a specific limitation. Changing every toggle makes failures harder to isolate.

Plugin compatibility is broad, not absolute

The usual compatibility direction is Bukkit/Spigot plugin → Paper → Purpur, but that is a rule of thumb, not a warranty. A plugin can depend on Minecraft internals, a server brand or behavior a fork changes. A Paper-only plugin cannot run on Spigot merely because Paper is based on Spigot.

Before selecting the server implementation, audit the few plugins your group actually needs:

• Read the plugin’s supported-platform and supported-version list.
• Check its release date and prefer plugins that use public APIs.
• Inspect the startup log; do not rely only on /plugins showing a green name.
• Test joins, permissions, inventories, portals and world generation on a copy.

Do not solve compatibility with an old JAR from an unofficial mirror. Paper warns that plugins have unrestricted machine access, while Spigot warns against random server JAR downloads. Treat both as executable code.

Performance: choose the baseline, then measure

Paper is the more defensible performance baseline because its additional optimizations and profiler are documented. That is not the same as declaring a universal winner.

A slow plugin, excessive entity count, new chunk generation, constrained CPU, storage latency or an overloaded host can dominate the difference between server JARs. Adding RAM also does not repair every low-TPS problem. Use our Minecraft server RAM guide for memory sizing, then profile the workload before changing dozens of server settings.

Test with a cloned world and plugin directory, keep Java, arguments and hardware constant, then reproduce real exploration, farms and player activity. Capture profiler output and change one variable at a time. A heavily “optimized” configuration can improve a headline number while making the game behave incorrectly.

How to migrate without trapping yourself

For a new server, selecting Paper or Purpur is straightforward: download the correct build for the Minecraft version, use the required Java version, accept the EULA, start once, then add plugins gradually. Paper publishes a current Java compatibility table and setup instructions.

For an existing server, stop and check the exact version-specific migration guide. The old advice to “swap the JAR and swap it back if needed” is no longer universally safe. Paper’s current migration documentation warns that world-storage differences in the 26.1 generation affect direct migration between Spigot/CraftBukkit and Paper. It also says moving from Paper back to Spigot is unsupported and may cause data loss.

A safe migration process is:

1. Stop the server cleanly and make a full, offline backup of worlds, configuration, plugin JARs and plugin data.
2. Store that backup outside the live directory, then restore it to a staging server.
3. Follow both projects’ instructions for that exact Minecraft version.
4. Start with the existing plugins, read the whole log, and resolve warnings.
5. Test dimensions, inventories, portals and plugin-owned data before touching the original.

Rollback means restoring the pre-migration backup, not putting the old JAR back. World-format, configuration and plugin-data changes may not be reversible with a JAR swap.

Updates deserve the same discipline. Paper’s update guide recommends backing up, updating plugins, stopping the server before replacing its JAR, and watching the startup log. It specifically discourages unattended automatic Paper updates because a new build can expose plugin conflicts. Use the equivalent official release process for Purpur or BuildTools for Spigot.

Final verdict by use case

• A first plugin server for friends: Paper. It offers the best general balance of compatibility, documentation, diagnostics and performance work. Our server-for-friends guide covers the broader setup decisions.
• A server that needs a documented Purpur-only setting: Purpur. Enable only the settings you can explain and test.
• A server constrained by explicit vendor support: Spigot, if the plugin vendor or host genuinely requires it.
• A technical Vanilla group: Consider Vanilla first; none of these Bukkit-derived implementations guarantees exact mechanics.
• A modded group: None of the three. Choose a compatible mod loader and modpack instead.
• An existing production world: Follow version-specific migration documentation and validate a restored copy.

If you have no special constraint and are opening a blank server directory today, start with Paper. Purpur should be an intentional choice for additional control, while Spigot should be an intentional choice for a compatibility or support requirement.