Paper vs Purpur vs Vanilla: Which Server Core to Choose for Minecraft

In short: Vanilla is "the way Mojang intended," but with no optimizations and no plugins; Paper is the industry standard for performance and compatibility; Purpur is that same Paper, but with hundreds of extra settings and gameplay tweaks. Whether you pick Paper or Purpur, you get a fast, stable server that runs plugins — the difference is in how deep the customization goes.

The core (the server jar) is the heart of your server. It decides how many players you can handle, how much you'll lag, whether plugins will run, and how flexibly you can bend the gameplay. Let's walk through the whole lineup in order, so you understand what inherits from what and can make an informed choice.

The core lineup: from Vanilla to Purpur

Every "Bukkit core" grew from the same tree. Each one takes the code of the previous and adds its own layer on top:

• Vanilla — Mojang's official server. No plugins, no optimizations, just vanilla mechanics.
• CraftBukkit — the historic fork of Vanilla that first added plugin support via the Bukkit API. Today it's barely used directly.
• Spigot — a fork of CraftBukkit with basic optimizations and an extended API. It was the standard for a long time, until Paper overtook it.
• Paper — a fork of Spigot with hundreds of performance patches, asynchronous processing and fine-grained configs. Today it's the de facto standard.
• Purpur — a fork of Paper (built on Pufferfish, to be exact) that adds a huge number of settings and gameplay tweaks.

There are also branches aimed at large projects: Pufferfish — a fork of Paper that pushes for even more aggressive optimization (asynchronous handling of some entities, improved mob AI), and it's exactly what Purpur is built on. Folia — an experimental fork of Paper with regional multithreading.

Why Paper beats Vanilla

Vanilla is great for playing with friends "as is," but the moment your server starts to grow, its tick engine begins to choke. Paper solves this on several levels at once:

• Performance. Asynchronous chunk saving and loading, optimized entity and redstone handling, smart "sleeping" of distant mobs. On the same hardware, Paper holds noticeably more players at a steady TPS.
• Plugins. This is the headline advantage over Vanilla — economy, land protection, permissions, minigames. All of that comes from Bukkit/Spigot plugins, which Vanilla simply can't run.
• Fine-grained tuning. The paper-world.yml and paper-global.yml files let you dial in dozens of parameters: mob spawn limits, entity tick range, hopper behavior, anti-crash patches.
• Stability. A pile of fixes for crash exploits and bugs that linger in Vanilla for years.

If your server has started to stutter, the first thing to do after switching to Paper is to set up entity limits properly. We've put together a detailed breakdown of what causes lag and how to cure it in our guide on why your server lags and how to fix it.

Which config files appear on Paper

Vanilla gets by with a single server.properties. Paper adds a whole set of YAML files on top of it, and that's exactly where all the optimization magic hides:

• paper-global.yml — server-wide settings: anti-exploit patches, autosave frequency, behavior behind a proxy.
• paper-world.yml — per-world settings: mob and entity tick range, spawn limits, hopper and redstone throttling.
• spigot.yml and bukkit.yml — parameters inherited from Spigot: view-distance, item merge-radius, per-chunk entity limits.

The server.properties file itself doesn't go anywhere — it's the base file for every core. If you want to get to grips with its keys (view-distance, simulation-distance, spawn-protection and the rest), we have a dedicated breakdown: configuring server.properties.

Purpur: Paper plus control over everything

Purpur isn't chasing TPS records — it inherits raw performance straight from Pufferfish and Paper. Its real selling point is something else: hundreds of extra settings, many of which change the gameplay itself. Examples of what you can switch on with a couple of lines in purpur.yml:

• Rideable mobs (saddle up almost any creature) and configurable creature behavior;
• Fine control over drops, XP, health and damage per mob type;
• Gameplay touches: lava-destructible items, TNT behavior, faster or slower crop growth;
• Extended control over spawning and AI that plain Paper doesn't offer.

Pufferfish and Folia — for serious load

Pufferfish makes sense when your server is genuinely hitting a performance wall: 50+ online, heavy mechanics, lots of entities. It squeezes out extra fractions of a TPS through asynchronous processing and optimized mob AI. On a regular survival server the difference from Paper is barely noticeable.

Folia takes a different approach to scaling. The world is split into regions, and each region is ticked on its own thread in parallel. This lets you actually use many CPU cores, but there's a catch: Folia breaks compatibility with ordinary plugins — only ones the author has flagged as folia-supported: true will load. Folia is for large networks with a distributed map, not your average server.

Core comparison table

Core and lag: what matters more than hardware

A common beginner mistake is thinking the right core will cure any stutter. In reality it's a combination of three things:

1. The core. Paper/Purpur take excess load off, but they don't work miracles on a weak server.
2. The hardware. Minecraft parallelizes poorly, so what matters is the clock speed of a single CPU core. Elysium runs AMD Ryzen 9 chips boosting to 5.0+ GHz, real DDR5 with no overselling and NVMe Gen4 — chunk loads and world saves don't drag down your TPS.
3. JVM flags. The right launch parameters and garbage collector (Aikar's flags) smooth out GC pauses and freezes.

We've got a dedicated breakdown of launch flags — optimizing with Aikar's flags. And if you want to figure out how much memory to allocate to the core and the world, check out our guide on how much RAM your server needs. Without enough RAM, even the most optimized core will keep running into the garbage collector.

How to move from Vanilla to Paper

Good news: Paper uses the same world format as Vanilla, so the migration is almost seamless.

1. Make a backup of your world and configs (on Elysium backups are taken automatically).
2. Stop the server.
3. Download the latest paper.jar for your game version and drop it in place of the old server.jar.
4. Start the server — Paper will generate its own configs (paper-world.yml, bukkit.yml, spigot.yml) and boot on your existing world.
5. Move your plugins into the plugins/ folder and tune the entity limits to fit your hardware.

In the Pterodactyl panel on Elysium, swapping cores is even easier — Vanilla, Paper, Purpur, Spigot, Forge, Fabric and NeoForge install in one click from a list, no manual jar downloads. If you're just getting started, there's a step-by-step walkthrough in our big guide on how to set up a Minecraft server.

Bottom line: what to choose

For the vast majority of servers, the answer to "Paper or Purpur" is this: start with Paper. It means stability, speed, enormous plugin compatibility and configs you can actually understand. Move to Purpur when you hit the ceiling of Paper's settings and want custom gameplay — the migration is free and lossless. Keep Pufferfish and Folia in reserve for genuinely large projects. And leave Vanilla for cozy, plugin-free games with friends. Remember: any core only shows its full potential on good hardware and with sensible JVM flags.