Paper vs Purpur vs Fabric: Which Jar to Run

Choosing the right server software is one of the most important decisions you will make when setting up a Minecraft server. The wrong choice can mean poor performance, incompatible plugins, or a modding experience that simply does not work. The right choice can transform a laggy 10-player server into a smooth 200-player network.

This guide covers every major option available in 2026, explains how they relate to each other, and gives you a clear recommendation based on your specific use case.

Quick answer: For most servers, run Paper: it is fast, stable, and runs the largest plugin ecosystem. Choose Purpur when you want deep gameplay customization, Fabric for performance mods and vanilla-parity technical play, and Spigot only as a legacy fallback when a specific plugin refuses to run on Paper.

---

What Is Server Software and Why Does It Matter?

When you run a Minecraft server, you are not running the game client. You are running a separate Java application that simulates the game world, handles player connections, processes game logic, and enforces rules. This application is called server software, and the compiled file you run is commonly referred to as a server jar.

The server jar you choose determines:

• Performance: How efficiently the server uses CPU and RAM, and how well it maintains 20 TPS (ticks per second, the target game speed)
• Plugin support: Whether you can install Bukkit, Spigot, or Paper API plugins
• Mod support: Whether you can install Fabric, Forge, or NeoForge mods
• Configuration depth: How granular your control is over gameplay mechanics
• Update speed: How quickly the software receives patches after a new Minecraft version releases

Understanding these differences will help you make a confident, informed decision rather than just copying what someone else uses.

---

The Minecraft Server Software Family Tree

Most server software in the Java Edition ecosystem descends from a common ancestor. Here is how they relate:

Mojang Vanilla
    └── CraftBukkit  (added the Bukkit plugin API, ~2011)
            └── Spigot  (performance patches + Bukkit API, ~2012)
                    └── Paper  (aggressive optimizations + Paper API, ~2016)
                            ├── Purpur  (Paper + extra gameplay config, ~2020)
                            └── Pufferfish  (Paper + async optimizations, ~2021)

Fabric  (independent, lightweight mod loader, ~2019)

Forge  (independent, powerful mod loader, ~2011)
    └── NeoForge  (Forge fork with modern architecture, ~2023)

Vanilla, Fabric, Forge, and NeoForge are independent of the Bukkit lineage. This means plugins written for Spigot or Paper will not work on Fabric or Forge, and vice versa for mods.

---

Detailed Breakdown of Each Server Software

Vanilla

Vanilla is the official server software released by Mojang. It receives updates on the same day as the client and contains no third-party modifications.

When to use Vanilla:

• You want a completely unmodified, pure Minecraft experience
• You are running a small private server for friends (under 10 players)
• You need to test resource packs, data packs, or command blocks in a reference environment
• You want guaranteed compatibility with every new Minecraft feature on day one

Limitations:

• No plugin or mod support whatsoever
• Poor performance at even moderate player counts
• Very limited configuration beyond server.properties
• No tick loop optimizations, meaning TPS degrades rapidly under load
• No async chunk loading or entity reduction features

Verdict: Vanilla is only appropriate for small private servers or testing environments. For anything serious, move to a fork.

---

Spigot

Spigot was the first major performance improvement over CraftBukkit and introduced the BungeeCord ecosystem. Released around 2012, it remains the baseline for plugin compatibility.

Key features:

• Full Bukkit and Spigot API support (the largest plugin ecosystem in Minecraft)
• Basic performance improvements: reduced entity tracking, configurable view distance, per-world settings
• spigot.yml configuration file with dozens of tunable parameters
• Built-in BungeeCord support for proxy networks

Performance: Spigot is meaningfully faster than Vanilla but is outclassed by Paper under real load. Its optimizations are mostly configuration-based rather than code-level rewrites.

Plugin support: Every plugin written for Bukkit or Spigot will run on Spigot. It is the compatibility baseline.

Update speed: Spigot releases are typically available within a few days of a new Minecraft version.

When to use Spigot:

• You need maximum plugin compatibility with very old or obscure plugins
• You have a specific plugin that is known to break on Paper
• You are building a network proxy setup that requires BungeeCord features at the server level

Verdict: Spigot is largely obsolete for new servers. Paper is faster, more configurable, and equally compatible with the vast majority of Spigot plugins. Choose Spigot only if a specific plugin requires it.

---

Paper

Paper is the most popular Minecraft server software in the world, and for good reason. It started as a Spigot fork in 2016 with the goal of fixing bugs and improving performance far beyond what Spigot offered. As of July 2026, Paper remains the most widely used Minecraft server software and the default recommendation for the vast majority of plugin-based servers.

Key features:

• Hundreds of upstream Spigot bug fixes
• Async chunk loading and generation (dramatically reduces main thread lag)
• Entity activation range with configurable wake-up behavior
• Async entity tracking
• The Paper API, which extends the Spigot API with additional events and utilities
• Configurable per-player mob spawn distances
• Built-in anti-xray (obfuscation-based, minimal CPU cost)
• Configurable item despawn rates, explosion behavior, and physics

Performance: Paper is the performance benchmark for plugin-based servers. The PaperMC documentation describes Paper as designed to greatly improve performance, and under sustained load it holds TPS noticeably better than Spigot. How much better depends on your configuration and workload, and we have not found a published, reproducible cross-jar benchmark that pins the gap to a specific percentage.

Plugin support: Paper supports all Bukkit and Spigot plugins. The Paper API is a superset, so plugins written specifically for Paper will not run on Spigot, but the reverse is generally fine.

Update speed: Paper typically releases builds within hours to a day of a Minecraft update, thanks to a large active maintainer team.

When to use Paper:

• You are running a public survival, SMP, or minigame server
• You want the best plugin ecosystem with strong performance
• You are hosting any server with more than 10 concurrent players
• You want frequent upstream fixes for Vanilla bugs

Verdict: Paper is the default recommendation for the vast majority of servers in 2026. If you are unsure what to use, start here.

---

Purpur

Purpur is a fork of Paper that adds an enormous number of gameplay configuration options without sacrificing Paper’s performance foundation.

Key features:

• Everything Paper offers, plus a large additional set of configurable options (see the Purpur configuration reference)
• Configurable mob behavior (rideable mobs, custom mob stats, drops, AI changes)
• Configurable player mechanics (disable fall damage, change sprint behavior, fly in survival)
• Message of the Day (MOTD) customization beyond Vanilla limits
• Additional API extensions for plugin developers
• Optional Pufferfish patches can be merged in some builds

Performance: Essentially identical to Paper for most configurations. A few Purpur-specific features add marginal overhead if enabled, but the core performance profile is the same.

Plugin support: Full Bukkit, Spigot, and Paper plugin support. Purpur-specific API is available for plugins that target it.

Update speed: Slightly behind Paper, typically one to two days after Paper releases for a given version.

When to use Purpur:

• You want deep control over game mechanics without writing custom plugins
• You are running an RPG, survival, or creative server with unique gameplay rules
• You want to tweak behavior that normally requires a dedicated plugin

Verdict: Purpur is an excellent choice for servers that need extensive customization. If you are already happy with Paper and want more knobs to turn, Purpur is a direct upgrade.

---

Pufferfish

Pufferfish is a Paper fork focused exclusively on performance optimizations, particularly for high-population servers.

Key features:

• Dynamic activation range (DAB): entities further from players are ticked less frequently, scaling with distance
• Async mob pathfinding
• Optimized entity brain tick scheduling
• Reduced redundant entity AI calls

Performance: Pufferfish targets high-entity, high-player-count scenarios, and the project describes itself as a high-performance fork of Paper designed for large servers. DAB is the headline saving: mob brain ticks are some of the most expensive work in the tick loop, so ticking distant mobs less often frees CPU time in proportion to how many mobs are sitting far from players. The project does not publish a percentage for that saving, and we have not measured one ourselves.

Plugin support: Full Bukkit, Spigot, and Paper plugin support.

Update speed: Updates can lag behind Paper and Purpur by several days to a week.

When to use Pufferfish:

• You are running a server with 100 or more concurrent players
• Your server has high entity density (mob farms, large towns)
• You have already optimized everything else and need more CPU headroom

Verdict: Pufferfish is a specialist tool. It is worth using on large servers, but for most use cases Paper or Purpur will be sufficient.

---

Fabric

Fabric is an independent, lightweight mod loader. It does not share any lineage with the Bukkit ecosystem and does not support Bukkit or Spigot plugins.

Key features:

• Extremely lightweight core with a modular design
• Fast update cycle: Fabric often has builds available within hours of a new Minecraft release
• Strong community of performance mods (Lithium, Ferium, C2ME, Krypton)
• Full access to Minecraft internals via Mixin
• Ideal for technical Minecraft, vanilla-adjacent gameplay with mods, and client-side mods

Performance: With optimization mods like Lithium and C2ME installed, Fabric can match or exceed Paper in specific scenarios. Without them, it is closer to Vanilla.

Plugin support: None. Fabric uses its own mod format entirely.

Mod support: Fabric has the largest and most up-to-date mod ecosystem in 2026, particularly for utility and technical mods.

Update speed: One of the fastest in the ecosystem.

When to use Fabric:

• You want mods, not plugins
• You are running a technical Minecraft server (farms, redstone, vanilla mechanics)
• You need the latest Minecraft version with mod support as fast as possible
• You want client-side optimization mods alongside server-side ones

Verdict: If you want mods, use Fabric. It is not interchangeable with Paper. They serve completely different audiences.

---

Forge

Forge is the original heavyweight mod loader, dating back to 2011. It powered the golden age of Minecraft modding and hosts thousands of mods.

Key features:

• Massive legacy mod catalog (Feed the Beast, Tekkit, and thousands of standalone mods)
• Deep API for game modification, including new dimensions, biomes, and block types
• Strong integration with complex mod packs

Performance: Forge has historically poor server performance. The overhead of its deep patching system adds significant CPU and memory cost.

Update speed: Forge is notoriously slow to update. It often lags behind Minecraft releases by weeks or months.

When to use Forge:

• You need a specific mod that is only available on Forge and has not been ported to Fabric or NeoForge
• You are running a legacy mod pack (1.12.2, 1.16.5, 1.18.2 era content)

Verdict: Unless you have a compelling reason to use Forge specifically, NeoForge is the better choice for new installations.

---

NeoForge

NeoForge is a fork of Forge created in 2023 by the majority of the Forge development team. It was created to address architectural debt, governance issues, and slow release cycles in the original project.

Key features:

• Modernized codebase with improved maintainability
• Faster update cycle than legacy Forge
• Backward compatibility with most Forge mods (varies by version)
• Active development with responsive maintainers

Performance: Marginally better than Forge due to codebase cleanup, but still heavier than Fabric.

Update speed: Significantly faster than Forge, approaching Fabric’s speed in some releases.

When to use NeoForge:

• You want heavy mod support with a more modern toolchain
• You are building a new mod pack and want long-term maintainability
• Your preferred mods have been ported to NeoForge

Verdict: For new Forge-style mod pack servers, NeoForge is the recommended default over legacy Forge.

---

Head-to-Head Comparison Table

Feature	Vanilla	Spigot	Paper	Purpur	Pufferfish	Fabric	Forge	NeoForge
Plugin support	None	Bukkit/Spigot	Bukkit/Spigot/Paper	Bukkit/Spigot/Paper	Bukkit/Spigot/Paper	None	None	None
Mod support	None	None	None	None	None	Fabric	Forge	NeoForge/Forge
Performance	Poor	Fair	Excellent	Excellent	Best (high load)	Good (with mods)	Poor	Fair
Config depth	Minimal	Moderate	High	Very High	High	Via mods	Via mods	Via mods
Update speed	Instant	Fast	Fast	Fast	Moderate	Very fast	Slow	Moderate
Ease of setup	Simple	Simple	Simple	Simple	Simple	Moderate	Moderate	Moderate
Stability	High	High	High	High	High	Moderate	Moderate	Moderate
Recommended for	Testing	Legacy	Most servers	Custom gameplay	Large servers	Tech/mod servers	Legacy packs	New mod packs

---

Head-to-Head Comparisons

These are the direct match-ups people search for most. Each verdict assumes a survival or SMP server on equivalent hardware.

Purpur vs Fabric

Purpur and Fabric are not interchangeable: Purpur runs Bukkit/Spigot/Paper plugins, Fabric runs mods. Choose Purpur for a plugin-driven survival or RPG server that needs deep gameplay config; choose Fabric for a modded or technical server. Raw performance is similar once Fabric has Lithium installed, so the real decision is plugins versus mods, not speed.

	Purpur	Fabric
Best for	Custom plugin servers	Modded / technical servers
Performance	Excellent	Good (with Lithium)
Plugins / mods	Plugins	Mods

Purpur vs Paper

Purpur is Paper plus a large set of extra gameplay options, at essentially identical performance. If you are happy with Paper and want more knobs (mob behavior, player mechanics, MOTD) without writing plugins, Purpur is a drop-in upgrade. If you want the fastest upstream updates and the largest tested user base, stay on Paper. World data is fully compatible between them.

	Purpur	Paper
Best for	Custom gameplay	Most servers
Performance	Excellent	Excellent
Plugins / mods	Plugins	Plugins

Spigot vs Fabric

Spigot is a plugin platform; Fabric is a mod loader, so they serve entirely different servers. Pick Spigot only if a legacy plugin refuses to run on Paper; pick Fabric for mods or client-side performance packs. For a modern plugin server, Paper beats both, and Fabric with Lithium outperforms plain Spigot under load.

	Spigot	Fabric
Best for	Legacy plugin servers	Modded servers
Performance	Fair	Good (with Lithium)
Plugins / mods	Plugins	Mods

Spigot vs Paper vs Purpur

All three run the same plugins, but Paper and Purpur outperform Spigot by a wide margin. Spigot is the legacy baseline; Paper adds hundreds of fixes and async chunk loading; Purpur adds gameplay config on top of Paper. For any new server, start with Paper and move to Purpur if you need more control. Spigot is rarely the right pick in 2026.

	Spigot	Paper	Purpur
Best for	Legacy	Most servers	Custom gameplay
Performance	Fair	Excellent	Excellent
Plugins / mods	Plugins	Plugins	Plugins

Whichever jar you land on, CraftRift supports one-click switching between Paper, Purpur, Fabric, and NeoForge on low-ping SEA nodes from $3/mo. Browse our Minecraft hosting plans.

---

Benchmark Comparison: TPS Under Load

CraftRift has not run a cross-jar TPS benchmark, and we could not find a published one with an open, reproducible methodology to cite. The precise TPS tables that circulate on hosting blogs and forums are largely re-quoted from each other with no test behind them, so we are not adding another one. What the projects’ own designs and documentation do support is an ordering, not a measurement:

Under sustained load	How it holds up
Vanilla	Degrades fastest. No tick loop optimizations, no async chunk loading, no entity activation range.
Spigot	Better than Vanilla, mostly through configuration limits rather than code-level rewrites.
Paper	A large step up from Spigot. Async chunk loading and entity activation range keep the main thread clear.
Purpur	Effectively Paper. Purpur’s additions are gameplay options, not tick loop changes.
Pufferfish	Paper plus DAB and async pathfinding, aimed squarely at the high-entity, high-player case.
Fabric + Lithium	Comparable to Paper for vanilla-style workloads, closer to Vanilla without optimization mods.

The jar you pick starts to matter most once you are past roughly 50 concurrent players or running heavy mob farms, and Vanilla and Spigot are the first to degrade. The only TPS numbers worth trusting are your own: run /tps and a profiler like Spark against your actual world, plugin list, and player count before and after a switch.

---

Which One Should You Pick?

Use this decision path to find your answer:

Do you want mods or plugins?

• Plugins: Continue below
• Mods: Jump to the mod section

For plugin servers:

1. Are you running a server with over 100 concurrent players or extremely high entity counts?

   • Yes: Use Pufferfish
   • No: Continue

2. Do you need extensive gameplay customization without writing plugins?

   • Yes: Use Purpur
   • No: Continue

3. Do you have a specific plugin that is documented to break on Paper?

   • Yes: Use Spigot
   • No: Use Paper

For mod servers:

1. Do you need a specific mod that only exists on Forge and has no NeoForge or Fabric port?

   • Yes: Use Forge
   • No: Continue

2. Are you building a new mod pack or server from scratch?

   • Yes, heavy content mods: Use NeoForge
   • Yes, lightweight or technical mods: Use Fabric

3. Do you need the fastest possible update cycle?

   • Yes: Use Fabric

---

How to Switch Server Software

Switching jars is straightforward, but a few precautions will prevent data loss.

Before you switch:

1. Stop the server completely
2. Create a full backup of your server directory, including world folders, plugins/, mods/, and all configuration files
3. Read the migration notes for your target software (especially when moving from Spigot to Paper or from Paper to Purpur)

Steps to switch:

1. Download the new server jar from the official source
2. Replace your existing jar file with the new one
3. Update your startup script to reference the new jar name
4. Start the server and review console output for errors
5. Test core functionality before inviting players back

Important notes:

• World data is almost always compatible between Vanilla, Spigot, Paper, Purpur, and Pufferfish. Your worlds will not be corrupted by switching within this family.
• Switching from a plugin-based server to a mod-based server (Fabric, Forge) requires a full world reset or a separate world folder. Plugins and mods are not compatible.
• Some Paper-specific configuration options have different defaults than Spigot, which can change world behavior slightly (notably chunk loading and entity behavior). Review paper-world-defaults.yml after migration.

Hosting platforms that support Pterodactyl, like CraftRift, make this process significantly easier. CraftRift provides one-click jar switching directly from the panel, so you can swap between Paper, Purpur, Fabric, NeoForge, and other supported jars without touching your startup scripts or SSH session. This is especially useful when testing a new software version before committing to it in production.

---

FAQ

Can I use Paper plugins on a Fabric server?

No. Paper plugins use the Bukkit/Spigot/Paper API, which is completely separate from the Fabric mod API. There is no compatibility layer that works reliably in production.

Is Paper always better than Spigot?

For almost all use cases, yes. Paper is faster, fixes more bugs, and has more configuration options. The only reason to stay on Spigot is if a plugin explicitly requires it, which is rare in 2026.

Does switching from Spigot to Paper break my plugins?

The vast majority of Spigot plugins run on Paper without modification. A small number of plugins that exploit Spigot internals or use reflection against specific Spigot classes may have issues, but this is uncommon. Test your plugin list in a staging environment before switching in production.

What is the difference between Purpur and Pufferfish?

Purpur focuses on configurability: it gives you more options to change gameplay mechanics. Pufferfish focuses on performance: it makes the server run faster under load through optimized entity and pathfinding code. Some server operators use a fork that combines both (sometimes called Purpurfish or similar community builds), though these are unofficial.

Purpur vs Fabric: which is better?

They target different servers. Purpur is the better choice for a plugin-based survival, RPG, or minigame server that needs deep configuration. Fabric is better for modded and technical servers. Performance is comparable once Fabric runs Lithium, so decide based on whether you need plugins or mods.

Is Purpur better than Paper?

Purpur is Paper with a large set of extra gameplay options and near-identical performance. It is better if you want to customize mob and player mechanics without plugins. Paper is better if you want the fastest updates and the most widely tested build. You can switch between them without losing world data.

Spigot vs Fabric: what is the difference?

Spigot runs Bukkit and Spigot plugins; Fabric loads mods, and the two are not compatible. Use Spigot only for a legacy plugin that will not run on Paper, and Fabric for mods or client-side performance packs. For a modern plugin server, Paper is the stronger default.

Can I run a Fabric server and a Paper server together in a network?

Yes, through a proxy like Velocity or BungeeCord. Each backend server runs its own software independently, and the proxy routes players between them. You can have a Paper-based survival server and a Fabric-based creative server under the same proxy network.

Which software has the best anti-cheat support?

Plugin-based servers (Paper, Purpur) have access to the widest range of anti-cheat plugins, including Grim, Matrix, and Vulcan. Fabric has anti-cheat mods but the ecosystem is smaller. Forge and NeoForge have very limited anti-cheat options.

How much RAM does each software type need?

As a baseline:

• Vanilla / Spigot: 2 to 4 GB for small servers
• Paper / Purpur / Pufferfish: 3 to 6 GB recommended, scales with player count
• Fabric: 4 to 8 GB depending on mod count
• Forge / NeoForge: 6 to 12 GB for typical mod packs (heavy mod packs can require more)

Is there a hybrid server that supports both plugins and mods?

Hybrid servers like Mohist and Arclight attempt to combine Forge or Fabric with the Bukkit plugin API. These projects are community-maintained, often unstable, and not recommended for production servers. Stability and compatibility issues are common, and neither the plugin nor the mod community officially supports them.

What is the best server software for a Minecraft network or hub?

Paper or Purpur on all backend servers, with Velocity as the proxy. Velocity is faster and more secure than BungeeCord, and it integrates natively with Paper’s modern forwarding mode, which improves both security and player data integrity.

---

Final Thoughts

The Minecraft server software ecosystem has matured significantly by 2026. For plugin-based servers, Paper is the clear default, Purpur is the upgrade when you need more control, and Pufferfish is the specialist tool for large player counts. For mod-based servers, Fabric leads for lightweight and technical setups, while NeoForge serves heavy modpacks.

The most important thing is to match the software to your server’s actual purpose. A survival SMP with 30 players and a dozen quality-of-life plugins is a Paper server. A technical server running complex farms with a small friend group is a Fabric server. A heavily modded adventure server is a NeoForge server.

Whatever you choose, make sure your host supports it. CraftRift supports all major server jars, and its Pterodactyl-based panel lets you switch between them in one click, so you are never locked into a decision you made on day one.

Start with Paper. You can always switch.