Paper vs Spigot vs Purpur vs Fabric: Best Minecraft Server Software Compared (2026)

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.

---

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 in almost every benchmark. 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.

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. It consistently outperforms Spigot by 30 to 60 percent in TPS retention under load, depending on the server configuration and workload.

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 over 300 additional configurable options
• 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 consistently outperforms base Paper in high-entity, high-player-count scenarios. The DAB system alone can reduce CPU usage by 15 to 25 percent on busy servers.

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

---

Benchmark Comparison: TPS Under Load

The following figures represent approximate TPS retention on a standard survival world with default settings, no heavy plugins, running on equivalent hardware (8 CPU cores, 16 GB RAM). These are representative estimates based on community benchmarks and testing.

Player Count	Vanilla	Spigot	Paper	Purpur	Pufferfish	Fabric + Lithium
20 players	18.5 TPS	19.5 TPS	19.9 TPS	19.9 TPS	20.0 TPS	19.8 TPS
50 players	14.0 TPS	17.0 TPS	19.5 TPS	19.4 TPS	19.7 TPS	19.0 TPS
100 players	8.0 TPS	12.5 TPS	17.5 TPS	17.3 TPS	18.8 TPS	16.0 TPS

Paper’s aggressive optimizations become decisive at 50 or more players. Pufferfish’s dynamic activation range provides clear advantages at 100 players. Vanilla and Spigot degrade sharply under any meaningful load.

---

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.

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.