Minecraft Server Cores Compared 2026: Spigot vs Paper vs Purpur vs Pufferfish vs Leaf

Run vanilla and you bleed 60-70% of your performance for nothing. This guide breaks down the five most popular server cores of 2026, shows real TPS numbers at 100/200/500 players, and tells you exactly which one to pick for your player count.

Why swap out the core in the first place

The vanilla server.jar from Mojang is written for clarity, not speed. Chunks load on the main thread, mobs path-find every tick, and entities tick even when nobody is around. At 30 players you can still play. At 100, the server drops to 12 TPS and every step feels like 300 ms ping.

Alternative cores solve two problems at once:

• Plugin API. The Bukkit/Spigot API is the de-facto standard. Without it you cannot run WorldGuard, LuckPerms, or Vault.
• Optimisation. Async chunk loading, rewritten path-finding, lazy ticking for inactive mobs, smarter network compression.

Every core in this article speaks Bukkit, so your plugins survive the migration. The catch: forks above Paper sometimes change vanilla behaviour, and we cover that below.

Spigot: the ancient base

Spigot appeared in 2013 as a CraftBukkit fork with a thin layer of optimisation. By 2026 standards it is legacy. You only want it in two cases:

1. You have an old plugin that Paper refuses to load with IllegalAccessError.
2. You write plugins and want to publish without depending on the Paper API.

Config sits in spigot.yml. The main knobs are view distance, entity activation range, and mob limits. At 100 players Spigot holds about 14 TPS. At 200 it drops to 13. CPU load is uneven: the main thread pegs at 100% while the rest of the cores sit idle.

There is no reason to start a new project on Spigot in 2026. But if your 2018 setup still hums, do not touch it.

Paper: the industry standard

Paper is a Spigot fork with hundreds of optimisations and bug fixes baked in. If you cannot decide which core to install, install Paper. About 90% of the top 100 servers on minecraft-mp.com run it.

What you get out of the box:

• Anti-Xray built into the core (no need for Orebfuscator).
• Async chunk loading that genuinely works on 1.20+.
• Fixes for dupe glitches, mending bug, and dozens of vanilla bugs.
• Its own API namespace (io.papermc.paper.*) for modern plugins.
• Configs split across paper-global.yml and paper-world-defaults.yml.

At 100 players Paper holds 18-19 TPS on a sane box (Ryzen 7 5800X3D, 32 GB RAM, NVMe). At 200 it sits around 17.8 TPS. Plugin compatibility is best in class: anything written for Spigot loads without changes.

The downside: Paper sometimes drifts from vanilla behaviour for the sake of speed. For example, fix-curing-zombie-villager-discount-exploit: true breaks the classic discount farm. Before pushing Paper to a survival server, walk through paper-world-defaults.yml and decide which patches you want.

Purpur: Paper with gameplay knobs

Purpur is a Paper fork by PurpurMC. Performance is identical to Paper give or take a percent. The selling point is hundreds of gameplay options that Paper does not expose:

• Fully customisable mob behaviour (aggression, speed, drops, health).
• Randomised rideables and skins (yes, the famous "pig with a tail").
• Toggles for AFK kick, sleep percent, headless pistons, and tons of small QoL.
• Built-in rideable mobs, dragon without rage, and dozens of survival treats.

The config lives in purpur.yml and it is genuinely huge. At 200 players Purpur shows the same 18 TPS as Paper, occasionally a touch higher thanks to incremental optimisations on top of Paper.

Pick Purpur if you run an SMP, RPG, or survival server focused on gameplay. For a pure technical hub it is overkill.

Pufferfish: Paper for heavy traffic

Pufferfish is a Paper fork by Kennytv (former ViaVersion maintainer). The goal is straightforward: squeeze maximum TPS out of a single jar on busy servers. It ships:

• Async path-finding for mobs (huge win on servers with farms).
• Multithreaded entity tracker in Pufferfish+ (the paid tier).
• Optimised AI for most mob types.
• Dynamic tick intervals for entities outside player view.

At 200 players Pufferfish posts 19.2 TPS against 17.8 on Paper. That is +5-8% on a stock setup. At 500 the gap widens to 12-15% because path-finding and AI become the bottleneck. Config lives in pufferfish.yml.

What Pufferfish breaks: it is incompatible with a handful of plugins that hook deep into mob code (some spawner plugins, certain MythicMobs versions). 95% of plugins run unchanged.

Pick Pufferfish from 100-150 concurrent players upward.

Leaf: the 2025 newcomer

Leaf is a Pufferfish fork that surfaced in late 2024 and grew through 2025. The team took Pufferfish and layered another wave of optimisations on top, including back-ports from Folia and their own tick rewrites:

• Lithium-style movement and physics tweaks.
• Reworked chunk system with priority loading.
• Async lighting and async hopper transfers.
• A leaf-global.yml packed with experimental toggles.

In lab benchmarks Leaf is +2-3% TPS over Pufferfish. Under real load the numbers vary: sometimes equal, sometimes worse because of fresh bugs. As of 2026 Leaf lives mostly on test rigs and small experimental servers.

The risks are obvious:

• Plugin compatibility may break between minor releases.
• Documentation is patchy. Many settings are described in two lines.
• The community is small and bug responses are slow.

Do not put Leaf on a paying server. For a home sandbox or an SMP with friends, fine.

TPS at 100/200/500 players

Averaged numbers from internal benches and public results (Java 21, Ryzen 9 7950X, 64 GB DDR5, NVMe, render-distance 8, simulation-distance 6):

Core	100 players	200 players	500 players
Vanilla	12.0	crash/8.0	crash
Spigot	16.5	13.5	9.0
Paper	19.2	17.8	14.0
Purpur	19.3	18.0	14.2
Pufferfish	19.6	19.2	16.5
Leaf	19.7	19.5	17.0

Numbers rounded. Your workload may vary by ±10%. The takeaway: under 100 online, Paper, Purpur, and Pufferfish are within margin of error. Past 200 online, Pufferfish and Leaf pull ahead.

Plugin compatibility

Spigot     ████████████████████  100%  (the base, everything works)
Paper      ████████████████████  100%  (Spigot API plus its own)
Purpur     ███████████████████░   98%  (rare conflicts)
Pufferfish ███████████████████░   97%  (issues with some mob plugins)
Leaf       ████████████████░░░░   85%  (fresh, lottery)

If you run 60+ plugins, start on Paper. Move to Pufferfish only after testing each custom plugin in staging.

Which core to pick

Short rule based on online count:

• Up to 30 players: Paper. Install and forget.
• 30-200 players: Paper or Purpur (if you want gameplay tweaks).
• 200-500 players: Pufferfish. The TPS gap pays for the testing time.
• 500+ players: Pufferfish with a hand-tuned pufferfish.yml, or step up to Folia (separate beast, see our Folia guide).

Leaf does not fit any production tier. It is a lab.

How to migrate to a new core

Migration between Paper, Purpur, Pufferfish, and Leaf takes five minutes because worlds and plugins are compatible:

# 1. Stop the server
screen -r mc
stop

# 2. Always back up first
cd /opt/mc-server
tar -czf backup-$(date +%Y%m%d).tar.gz world world_nether world_the_end plugins/

# 3. Download the new jar (example: Paper 1.21.4)
wget -O paper-new.jar https://api.papermc.io/v2/projects/paper/versions/1.21.4/builds/latest/downloads/paper-1.21.4-latest.jar

# 4. Swap the jar
mv server.jar server.jar.old
mv paper-new.jar server.jar

# 5. Start it up
java -Xms8G -Xmx8G -jar server.jar nogui

For Purpur, Pufferfish, and Leaf the swap is identical, only the download URL differs. After the first start the core writes its own configs (purpur.yml, pufferfish.yml, etc.), tune them later.

Rolling back works the same way. Paper reads Spigot worlds, Paper reads Purpur worlds. NBT data is compatible. The one caveat: if you used Purpur-only blocks or enabled exotic mechanics, the world may lose part of its content on rollback.

paper.yml gotchas

Paper and its forks optimise aggressively and do not always preserve vanilla logic. The most common surprises:

# paper-world-defaults.yml
unsupported-settings:
  fix-curing-zombie-villager-discount-exploit: true   # Kills the discount farm
  allow-tripwire-disarming-exploits: false            # Changes trap mechanics

entities:
  spawning:
    per-player-mob-spawns: true                       # Changes mob spawn distribution
  behavior:
    mobs-can-always-pick-up-loot:
      zombies: false                                  # Zombies stop picking up armour

Walk through paper-world-defaults.yml before pushing Paper to a survival server. Half of the "weird mob behaviour" bug reports get fixed by flipping a single setting back to vanilla. Docs at docs.papermc.io.

Java 21 is mandatory

Starting with Minecraft 1.21+, every core listed here requires Java 21. Java 17 will not start Paper, Purpur, or any fork. On Ubuntu 24.04:

sudo apt update
sudo apt install -y openjdk-21-jre-headless
java -version  # should print 21.x.x

Use Aikar's flags for GC:

java -Xms8G -Xmx8G \
  -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 \
  -jar server.jar nogui

G1GC on Java 21 behaves better than on 17 and consistently keeps pauses under 50 ms on 8-16 GB heaps.

FAQ

Will a Forge mod plugin run on Paper

No. Paper does not load Forge mods and does not understand their API. If you need plugins and mods at the same time, install a hybrid: Mohist, Magma, or Arclight. They are heavier on performance and stability, but they are the only option to run a Bukkit plugin alongside a Forge mod.

Should I run Folia

Folia is a PaperMC fork that splits regions across threads. It makes sense at 500+ online or when you saturate a single thread at 200-300. Many plugins are incompatible (they need explicit Folia support), and the multi-threaded API is still stabilising. For most servers under 500 online the answer is no.

Is Pufferfish actually better than Paper

At 100 players the difference is within noise. At 200, +5-8% TPS consistently. At 500, up to +15% thanks to async path-finding and optimised AI. Plus a dozen knobs in pufferfish.yml that Paper does not expose. If you have 50 online, you will not notice.

Is Leaf production-ready

As of 2026, use at your own risk. The fork is fresh (December 2024), under active development, with frequent breaking changes. I would not put Leaf on a server where players pay for ranks and expect 99% uptime. For a test bench or a friends-only SMP, fine.

Can I downgrade from Purpur back to Paper

Yes, worlds and plugins are compatible. Stop the server, back everything up, swap server.jar to Paper, start. The one note: remove Purpur-only plugins and blocks first, otherwise the server may complain about unknown NBT tags. Same applies for Pufferfish and Leaf back to Paper.

Which jar do I download for 1.21.4

• Paper: api.papermc.io/v2/projects/paper
• Purpur: purpurmc.org/download
• Pufferfish: github.com/pufferfish-gg/Pufferfish
• Leaf: leafmc.one (current as of 2026)

Always grab the latest build. Do not pull random jars from forums.

Why is Spigot still being downloaded

Inertia plus a couple of specific use cases. Some admins keep a 2017 setup and fear migration. Some plugin authors do not want the Paper API as a dependency. There is no reason to start a new 2026 server on Spigot.

What to actually do

1. If you run Vanilla or Spigot and the player count is climbing, move to Paper. One hour of work, +30-50% TPS.
2. Want to tune gameplay and mob behaviour? Stack Purpur on top of Paper and dig into purpur.yml.
3. Crossed 150-200 online? Test Pufferfish in staging, then push to prod.
4. Before any migration: back up worlds, back up plugins/, back up configs. Do not skip this.

And remember: a core does not fix a badly tuned server. If you run 50 spawner farms and 200 hoppers in loaded chunks, no Pufferfish will save you. Optimise the world first, then swap the core.