Vanilla vs Spigot vs Paper — Which Minecraft Server Should You Use?

Every week someone asks which server jar to use, and the answer is almost always the same. But "almost" is where the interesting part is — there are real cases where Paper is the wrong choice.

TL;DR: Plugins and no client mods → Paper. Technical survival with farms that depend on exact vanilla behavior → Fabric with performance mods, or vanilla. Modpack → NeoForge (or Forge for older packs). Spigot and CraftBukkit → no reason left to pick them for a new server.

Plugins vs mods — the split that decides everything

This is what most comparisons skip, and it's the actual first question.

• Plugins run only on the server. Players join with a normal unmodified client. Permissions, economy, protection, minigames, chat — all plugins. Bukkit API → Spigot → Paper is the plugin family.
• Mods change the game itself: new blocks, items, dimensions. Usually the client needs the same mods installed. Forge, NeoForge and Fabric are mod loaders.

You can't load Bukkit plugins into Forge, and you can't load Forge mods into Paper. Hybrids that try to do both exist, they've always been fragile, and I don't run them on anything I care about. Pick a side.

Vanilla

Mojang's own server.jar. No plugins, no mods, no config beyond server.properties.

java -Xms2G -Xmx2G -jar server.jar --nogui

Good for: exact vanilla behavior, small friend groups, testing. Every farm, every redstone contraption, every quirk works exactly like singleplayer — because it's the same code.

Bad for: performance under load, any kind of admin tooling. No permissions system beyond op levels, no protection, no anti-grief. Most of the main tick still runs on one thread, so one busy area slows everyone down.

CraftBukkit and Spigot

CraftBukkit was the original Bukkit implementation. Spigot is the fork that made it fast enough to be useful, and that's where the Bukkit plugin ecosystem grew up.

You don't download Spigot — for licensing reasons you build it yourself with BuildTools:

mkdir ~/buildtools && cd ~/buildtools
wget https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar
java -jar BuildTools.jar --rev 1.21.8

That pulls Mojang's server, decompiles, patches and compiles. Takes a while, needs git and a decent amount of RAM.

Good for: honestly, very little in 2026. The odd plugin that explicitly refuses to run on Paper. Those exist, but rarely.

Bad for: performance (Paper is faster), convenience (BuildTools on every update), and proxy setups — Spigot can't do Velocity's modern forwarding. Both Velocity from scratch and the Velocity migration guide assume Paper backends for that reason.

Paper

Paper started as a Spigot fork with a huge pile of performance patches, and is what most plugin servers run. Since around 1.21.4 Paper is a hard fork — it no longer pulls in Spigot's changes. Spigot plugins still load on Paper, but the two APIs will slowly drift apart over time.

What you get over Spigot:

• Async chunk loading and saving, plenty of entity and tick optimizations. The difference shows on any server with more than a handful of players.
• Lots of config knobs in config/paper-global.yml and config/paper-world-defaults.yml — entity limits, despawn ranges, hopper behavior, anti-xray.
• Modern Velocity forwarding support built in.
• Spark profiler bundled, so /spark profiler works out of the box when TPS drops.
• Paper-only plugins — some newer plugins use Paper API and won't load on Spigot. The reverse is basically never true.

Good for: everything plugin-based. It's my default; the full Linux setup with systemd and flags is in Minecraft Java server on Linux.

Gotcha: Paper fixes things technical players call features

Paper patches several well-known exploits by default: TNT duplication, rail and carpet duplication, breaking bedrock with pistons, headless pistons. On a public server with economy plugins, that's exactly what you want. On a technical survival server where people build TNT duping world-eaters, it breaks their builds and they will tell you about it.

Some of these can be turned back on in paper-global.yml:

unsupported-settings:
  allow-piston-duplication: true
  allow-headless-pistons: true
  allow-permanent-block-break-exploits: true

The section name is the hint — Paper doesn't support these, and there's no guarantee every farm behaves 1:1 like vanilla afterwards. On top of that, the Spigot-inherited performance settings (entity activation ranges, item and XP merging) change how some farms behave unless you tune them back. If exact vanilla behavior is the whole point of your server, Paper is the wrong base.

Purpur

Paper fork with many more gameplay toggles: rideable mobs, configurable mob behaviors, all sorts of server-side gameplay changes. Runs Paper plugins.

Good for: survival servers that want to customize gameplay without writing plugins.

Bad for: anything where you want to stay close to upstream. It's another layer of patches, and it trails Paper releases.

Folia

Also from PaperMC. Folia splits the world into regions that tick in parallel on different threads. In theory, much higher player counts on a single world.

The catch: most plugins don't work. Plugins have to be explicitly written to be Folia-compatible, because the threading model breaks the assumptions the Bukkit API was built on. Many popular plugins don't support it, and there are fewer debugging tools. PaperMC themselves say it's not for small servers.

Good for: big servers with a dev team that can audit or write their own plugins.

Bad for: basically everyone reading this. Two threads doing nothing aren't faster than one.

Fabric

Lightweight mod loader, updates fast to new Minecraft versions. Two distinct use cases:

1. Vanilla+ performance. Server-side-only mods like Lithium (game logic optimizations that aim to keep vanilla behavior) and FerriteCore (memory). Players join with a vanilla client. This is the go-to for technical servers: much faster than vanilla, mechanics stay vanilla.
2. Actual modding — content mods that players also install.

Plugins don't work. For permissions etc. there's a Fabric ecosystem (LuckPerms has a Fabric build), but it's much smaller than Bukkit's.

Forge and NeoForge

The big content-modpack loaders. NeoForge split off from Forge in 2023, and most active development and newer modpacks moved there. Forge still matters for older modpacks — a lot of popular 1.20.1 packs are Forge.

Rule: run whatever loader and version the modpack ships with. Don't "upgrade" a Forge pack to NeoForge yourself. Modpack servers are a different beast in terms of RAM and tuning — my Forge / NeoForge modpack server post covers that.

Proxies are a separate question

Velocity and BungeeCord aren't server software in this sense — they sit in front of several backend servers and link them into a network. The backends behind them are almost always Paper. If that's where you're headed: Velocity from scratch, or the BungeeCord network setup if you need Bungee.

Gotcha: switching software on an existing world

Moving from vanilla or Spigot to Paper is easy: stop, back up, swap the jar, start. Paper handles the world.

Two things to watch:

• World folder layout. Vanilla keeps the Nether and End inside world/ (world/DIM-1, world/DIM1). Bukkit-family servers use separate world_nether and world_the_end folders and migrate them on first start. Going back to vanilla means moving those dimension folders back manually.
• Back up first. Not "I have yesterday's backup". Stop the server, copy the whole directory, then swap. Rsync pattern: rsync backups on Linux.

Going from Paper to Fabric or Forge is a bigger step: plugins are gone, plugin data (protections, economy balances) doesn't carry over.

Java version

Same for all of them: what Java you need depends on the Minecraft version, not the server software. 1.20.5 and newer need Java 21. If a jar crashes immediately with UnsupportedClassVersionError, it's the Java version, not your config.

My decision, short

• New server, normal players, plugins wanted: Paper. No discussion.
• Technical survival with farms: Fabric + Lithium, or vanilla if it's small.
• Modpack: whatever the pack ships with.
• Network: Paper backends behind Velocity.
• Folia: only if you know why you need it.
• Spigot: only if a specific plugin forces you.

Related posts

• PaperMC Download API v3: Why Your "latest" One-Liner Returns 404
• Pelican Panel — the Pterodactyl Successor I Switched To
• Migrating from BungeeCord/Waterfall to Velocity — A Practical Walkthrough