Where Paper falls short:

• Config depth. Some things you might want to tweak are locked.
• Optimization ceiling. You can squeeze more TPS with forks that focus on perf.

Pick Paper if: you run a server for 5 to 30 players, care about plugin stability, and don't want to think about this decision again for 12 months.

Purpur: Pufferfish performance plus hundreds more knobs

Purpur is the fork people underestimate. Most comparisons describe it as "Paper with extra config options," and that's true, but it misses the bigger fact.

Does Purpur include Pufferfish patches?

Yes. Purpur is built on top of Pufferfish, which is built on top of Paper. Purpur's official documentation confirms it imports the APIs and patches from Pufferfish, Paper, Spigot, and Bukkit. That means a Purpur server inherits Pufferfish's performance work (async mob pathfinding, SIMD optimizations) and then layers its own configuration surface on top.

So the real mental model is a stack, not three parallel options:

vanilla → Spigot → Paper → Pufferfish → Purpur

Why Purpur is great:

• Inherits Pufferfish's performance patches, so it's not "Paper-speed," it's Pufferfish-speed
• Every setting Paper has, plus hundreds more: rideable mobs, custom AI tweaks, per-mob gameplay tuning, "can endermen pick up blocks" level detail
• 100% Paper plugin compatibility
• Active development, ships quickly after Paper releases

Where Purpur falls short:

• The extra options can feel overwhelming to new admins
• If you're never going to touch the knobs, the config surface is dead weight (the perf inheritance still applies though)

Pick Purpur if: you run a community server where players request gameplay tweaks ("can we make phantoms rarer", "can we speed up crop growth"), or you want Pufferfish's optimizations with more tuning headroom.

Purpur vs Pufferfish: the head-to-head

Short version: Purpur includes Pufferfish's performance patches, so the performance gap between them is small. Pick Pufferfish for a lean, optimization-only server. Pick Purpur when you also want its huge config surface. Pufferfish updates can land slightly earlier since Purpur builds downstream of it.

Practical differences that matter:

If you're choosing purely on speed, the honest answer is you probably won't feel a difference between them on most workloads. Choose on the config surface instead.

Pufferfish: the lean performance fork

Pufferfish was built specifically for high-load servers. Think 40+ players, large redstone contraptions, heavy mob farms.

Why Pufferfish is great:

• Measurable TPS gains under heavy load (our internal testing shows 8 to 15% on 40+ player scenarios with heavy entity counts)
• Async mob pathfinding (DAB, Dynamic Activation of Brain) keeps mobs from blocking the main thread
• SIMD-optimized math operations
• Near-complete Paper plugin compatibility

Where Pufferfish falls short:

• Overkill for small servers. On 5 to 10 player servers you won't notice any difference.
• A few edge-case plugins that touch entity internals can behave oddly
• Smaller community means fewer guides when something breaks

Pick Pufferfish if: you run a mid-to-large server where TPS drops hurt and you want optimizations without Purpur's config sprawl.

Leaf vs Leaves: two different forks, one confusing letter

This catches everyone. Leaf and Leaves are separate projects with different goals. If you searched "leaf vs purpur" and got results about Leaves (or the reverse), this is why.

Leaf: the high-player-count performance fork

Leaf (by Winds Studio, at leafmc.one) is a Paper fork focused on balancing performance, vanilla mechanics, and stability. It's built for servers with high player counts or high entity counts: enhanced async systems, optimized chunk generation, improved resource management. Recent community benchmarks have measured Leaf meaningfully faster than stock Paper on entity-heavy workloads.

Pick Leaf if: you're running a big network or entity-heavy server and want newer async optimizations than Pufferfish ships, and you're comfortable with a younger project.

Leaves: the vanilla-parity fork for technical players

Leaves (by LeavesMC, at leavesmc.org) has a completely different mission: repairing vanilla behaviors that Paper changes. Paper patches some vanilla mechanics for safety and performance, which breaks certain technical-Minecraft contraptions (specific farm designs, update suppression, quasi-connectivity tricks). Leaves restores vanilla parity for those, so technical players get Paper's plugin ecosystem without losing their machines.

Pick Leaves if: your community builds technical contraptions that break on Paper, and you want vanilla behavior with plugin support. It is NOT primarily a performance fork.

Leaf vs Purpur in one line

Leaf chases raw throughput for big servers. Purpur chases configurability on a Pufferfish base. A 100-player network leans Leaf. A 20-player community server with custom gameplay leans Purpur.

What the benchmarks actually say

We run these forks in production across different workload profiles. The honest short version:

• Under 10 players, vanilla-ish gameplay: all of them behave identically. You will not notice a difference.
• 10 to 30 players with 15 to 25 plugins: Paper and Purpur feel the same day to day. Pufferfish and Purpur show marginal TPS improvements under spikes.
• 40+ players, heavy farms, large worlds: the performance forks (Pufferfish, Leaf, Purpur via its Pufferfish base) separate from stock Paper. TPS under load is meaningfully better.
• Technical Minecraft community: Leaves is the only one that restores the vanilla behaviors your players' contraptions depend on.
• Modded Paper hybrid (Mohist or Arclight): stick with Paper. Modded compatibility layers target Paper specifically and struggle with fork-specific changes.

Your mileage will vary based on plugin mix, hardware, and playstyle. These are patterns, not guarantees.

How to switch forks (it's a 3-minute job)

Switching between Paper-based forks is safer and simpler than most people expect:

1. Stop the server and back up your worlds folder plus plugin configs
2. Replace the server jar. Download the new fork's jar, drop it in place, update the start script if the filename changed.
3. Start the server and watch the console for plugin warnings on first boot. Most plugins will just work.

On BruceNode you can do this from the panel's version picker, no SFTP required. One-click reinstall covers Paper, Purpur, Spigot, Fabric, Forge, and NeoForge.

The decision tree

• 2 to 10 players, no heavy plugins: Paper. Move on.
• 10 to 30 players, community server with gameplay tweaks: Purpur.
• 30+ players, TPS is your bottleneck, minimal config appetite: Pufferfish.
• Big network, high entity counts, comfortable with newer software: Leaf.
• Technical Minecraft community with vanilla-dependent contraptions: Leaves.
• Modded Paper hybrid: Paper. Don't fork further.

Final take

Most servers will never need anything other than Paper. The "which fork is best" conversation online feels bigger than the actual performance gap on real servers. Paper is the right default. Purpur is the right upgrade when you want gameplay knobs (and you quietly get Pufferfish's speed with it). Pufferfish is the right upgrade when you have an actual TPS problem. Leaf is the right bet for big entity-heavy networks. Leaves is the specialist pick for technical-vanilla communities.

We built BruceNode to make this specific decision painless: one-click installs for every major Minecraft fork, so you can try Paper today, swap to Purpur tomorrow, and benchmark Pufferfish next week without ever touching SFTP.

New customers get 20% off the first invoice with code BRUCE20. Try it at brucenode.com/minecraft-hosting.

Related reading:

• How to install Fabric on a Minecraft server (2026)
• Minecraft server RAM calculator
• Minecraft hosting plans

Related guides

• Install a Fabric Minecraft server in 2026
• Choosing your Minecraft server plan
• Best Minecraft server hosting in 2026