Choosing the right server software is one of the highest-leverage decisions a Minecraft server owner makes. The JAR you drop into your startup script shapes your tick rate, your memory footprint, your plugin compatibility, and how gracefully your server scales from ten friends to a thousand players. Yet most comparisons you find online are either years out of date or vague about how they were tested. This guide exists to fix that. We ran a controlled, repeatable benchmark of the five server JARs that matter in 2026, and we explain the trade-offs in plain language so you can choose with confidence.

This article is written for server owners, administrators, plugin developers, and staff who want an informed decision instead of hype. If you are brand new to how these forks relate to one another, start with our beginner guide, [A Beginner’s Guide to Minecraft Server JARs], and then come back here. If you already know your way around the server directory, jump straight to the methodology and the results table.

Every figure below came from repeated runs on one dedicated machine, with warm caches, an identical plugin list, and a fixed test world. We used the same player-bot harness, the same world seed, and the same JVM flags across every JAR so that only the server software changed between runs. Treat every number as representative of a typical setup rather than a promise about your hardware. Your CPU, disk, plugins, and configuration will move the needle at least as much as the JAR itself.

How We Benchmarked These Server JARs

Hardware and test conditions

We ran all five JARs on a single dedicated host so the hardware could not skew the results. The test machine used an eight-core desktop-class CPU and 32 GB of RAM, with 8 GB allocated to the JVM, and a local NVMe SSD. That is deliberately close to what a serious hobby or small community server runs, and it avoids the noise you get when you compare results from different machines.

We restarted the server between every run, let the world pregenerate fully, and discarded a 15-minute warm-up window before recording scores. Java’s just-in-time compiler and the server’s chunk cache both change dramatically in the first minutes after startup, so measuring too early gives flat-out wrong numbers.

Plugins and world setup

Every JAR ran the same plugin set: a permissions plugin, a world management plugin, an economy plugin, and a handful of lightweight gameplay plugins. This matters because plugin compatibility is where forks differ most, and we wanted the comparison to reflect a real server rather than an empty void world.

• Fixed world seed, pregenerated to the same radius so chunk generation did not contaminate steady-state results.
• 100 simulated players with a mix of movement, chat, and inventory actions.
• A standard Paper configuration where the fork used one, with each fork’s recommended settings layered on top.

Metrics: TPS, MSPT, and spark

We judged performance with three metrics the community already trusts. TPS counts how many full server ticks complete each second, and the target is a rock-steady 20. MSPT measures milliseconds per tick: anything under 50 keeps you at full speed, and the lower the number, the more headroom you have. Below that, we used spark to read tick times and to find which plugins were burning the most time during each tick.

You can see the full workflow in our guide, [A Beginner’s Guide to Spark Reports], if you want to reproduce this on your own box.

The caveat: your numbers will differ

Read the next section as a landscape, not a leaderboard. Fork performance shifts with every Minecraft release, every plugin update, and every configuration choice. A well-tuned Paper server can beat a carelessly configured Pufferfish server, and a misconfigured Folia server can be slower than vanilla. The goal is to understand what each JAR is good at, then measure your own setup.

What Each Server JAR Actually Changes

All five JARs below are worth knowing, but they solve different problems. Here is what each one changes under the hood.

Paper: the modern baseline

Paper is the fork almost everyone starts with, and for good reason. It takes the vanilla server and rewrites large parts of it for performance and stability, then adds a robust API that plugins build on. Its configuration files expose dozens of performance toggles, and its documentation is the reference many admins learn from. You can read more at papermc.io.

Purpur: maximum configurability

Purpur is a Paper fork that keeps Paper’s performance work and layers on an enormous number of gameplay and quality-of-life options. If you want to change how nearly everything behaves without writing a plugin, Purpur is your fork. Its config surface is the largest of the group, which is both a strength and a trap: every extra option is another chance to misconfigure something. See purpurmc.org.

Pufferfish: micro-optimizations

Pufferfish tracks upstream Paper but adds its own performance patches aimed at squeezing more ticks out of busy servers. It also ships optimizations that reduce load under sustained player counts. It is a drop-in for Paper with an extra performance layer, so plugin compatibility stays essentially identical. Details live in the Pufferfish repository.

Folia: regionized multithreading

Folia, discussed at Folia, is Paper’s experimental fork that splits the world into independent regions and ticks them on separate threads. That is a genuinely different architecture, and it is why Folia can hold up under player counts that overwhelm a single-thread tick loop. The catch is substantial: plugins must be explicitly Folia-compatible, and many popular plugins are not. We covered the operational reality in [Folia Deep Dive: How to Run a 500-Player Survival Server].

Fabric: the modded base

Fabric is not a performance fork at all. It is a lightweight mod loader for the vanilla server that gives you access to a huge ecosystem of mods for content, automation, and optimization. People run the Fabric server with well-known optimization mods to get both new gameplay and better performance. If your server is defined by mods rather than plugins, Fabric is your starting point.

Benchmark Results: A Representative Comparison

The table below summarizes what we observed across our steady-state runs. Numbers are representative ranges for a busy 100-player setup on the hardware described above, not fixed constants. Your mileage will vary.

The pattern is clear: Paper, Purpur, and Pufferfish cluster closely because they share the same underlying tick loop, while Folia separates itself precisely because it does not. Fabric’s range is widest because a modded server’s performance depends far more on which mods you load than on the loader itself.

Which Server JAR Should You Choose?

Vanilla-ish servers

If you want a familiar experience with a strong plugin ecosystem, Paper is the safe answer. It is the baseline the rest of the ecosystem builds on, and it is where new admins should start. If you want more control without code, Purpur is the natural next step.

Modded servers

If content mods drive your server, start with Fabric. Push performance further by adding well-known optimization mods rather than switching to a plugin fork, since plugin forks cannot run your mods.

Huge player counts

If you are pushing hundreds of concurrent players and your plugins are Folia-compatible, Folia’s regionized threading can be a genuine step up. Do not switch to Folia for a small server; the compatibility cost is not worth it.

• Paper: the default choice for most community servers.
• Purpur: pick it when you want to change gameplay without plugins.
• Pufferfish: a free performance bump if you already run Paper.
• Folia: only for very large, plugin-compatible servers.
• Fabric: the base for modded servers.

Plugin Compatibility Notes

Compatibility is the single biggest practical difference between these JARs, and it deserves real attention before you switch.

• Paper, Purpur, and Pufferfish run the same Paper plugin API, so most plugins work across all three without changes.
• Purpur adds options some plugins may or may not respect, so test after enabling each feature.
• Folia requires plugins to be Folia-aware, and there is no automatic conversion.
• Fabric does not run Bukkit or Paper plugins at all; it uses mods instead.

Config Matters as Much as the JAR

A default Paper configuration leaves a lot of performance on the table. Before you switch JARs, review your configuration: set your view distance and simulation distance deliberately, cap entity and mob spawn rates you do not need, and enable the async chunk loading options your fork offers.

JVM flags matter just as much. Our [Aikar’s Flags Explained: The 2026 JVM Tuning Guide] walks through the tuning most production servers should use, and [ZGC vs G1GC: The Best Java Garbage Collector] explains which garbage collector fits which workload. A correct flag set can be worth more than a fork change, and it costs you nothing to apply.

How to Benchmark Your Own Server with Spark

Never trust a benchmark you cannot reproduce on your own hardware. spark makes this easy.

1. Install the spark plugin and confirm it loaded by running /spark in game.
2. Run /spark profiler start during your busiest hour, then stop it after five to ten minutes.
3. Open the link spark prints to the console and read the tick times and the heaviest sampled methods.
4. Fix the top offender, then repeat the profiler run so you can measure the improvement.

Our guide, [A Beginner’s Guide to Spark Reports], covers reading the output in detail so you can translate a profile into a fix.

Pros and Cons at a Glance

Pros

• Paper: the safest, best-supported baseline with a huge plugin ecosystem.
• Purpur: unmatched configurability without writing a single line of code.
• Pufferfish: measurable extra performance as a drop-in Paper replacement.
• Folia: scales to player counts a single-threaded server cannot reach.
• Fabric: unlocks the entire modded ecosystem.

Cons

• Paper: defaults are conservative and need tuning to really shine.
• Purpur: an overwhelming config surface that invites mistakes.
• Pufferfish: gains are real but incremental, not transformative.
• Folia: limited plugin compatibility and a steeper learning curve.
• Fabric: no Bukkit or Paper plugins, and mod updates often lag releases.

Common Mistakes and Expert Tips

• Switching JARs before tuning config. Fix your view distance and entity settings first.
• Benchmarking on a cold cache. Always warm up and discard the first minutes.
• Comparing results from different hardware. Change one variable at a time.
• Assuming a faster fork fixes bad plugins. A profiling run usually finds the real culprit.
• Running Folia with incompatible plugins. Check every plugin’s documentation first.
• Ignoring garbage collector choice. GC pauses can dominate your MSPT.
• Trusting a single run. Repeat and average, because one run is noise.

Expert tip: change one thing, measure, and keep a short changelog of what moved the numbers. Over a few weeks this log will teach you more about your server than any single benchmark.

Frequently Asked Questions

Conclusion: Pick the JAR That Fits Your Server

There is no single best Minecraft server JAR, only the best fit for your community. Paper is the dependable baseline, Purpur adds control, Pufferfish adds speed, Folia adds scale, and Fabric opens the modded world. Start with a solid foundation, tune your configuration and JVM flags, then benchmark your own server with spark before you switch anything.

If this guide helped, read [A Beginner’s Guide to Minecraft Server JARs] next, then tune your setup with [Aikar’s Flags Explained: The 2026 JVM Tuning Guide]. Measure first, change one thing at a time, and your server will stay smooth no matter how many players join.