Vanilla vs Paper vs Folia: Where Each Server Software Fits
What Vanilla, Paper and Folia each change about how a Minecraft server ticks the world, where Folia's regionised threading helps and where it doesn't, and how to pick the right one for your server.
ChunkPod Team · · 9 min read
Vanilla vs Paper vs Folia: Where Each Server Software Fits
Three server jars, three different design goals. Vanilla is what Mojang ships. Paper is what most plugin servers run on. Folia is the newer fork from the Paper team that spreads the world across CPU cores. They aren't really competing for the same job, and picking between them is less about which is fastest and more about which one is built for the server you want to run.
What Vanilla actually is
Vanilla is the server.jar you download from minecraft.net. It runs Minecraft the way Mojang built it, with the exact ticking, mob AI, world generation and physics you get in single-player. There's no plugin API. You can add datapacks, resource packs and command blocks, but you can't drop in a JAR that adds new commands or new blocks.
The main game loop is single-threaded. Some jobs like chunk I/O and network handling run on other threads, but every tick of the world happens on one CPU core. When you push a vanilla server hard, you feel it in the tick loop first.
That sounds like a limitation, and it is, but vanilla has real uses:
- Servers that want the exact behaviour speedrunners and technical players expect. Redstone timings, mob spawning, farm rates: all of it stays true to the single-player game.
- Small SMPs where five to ten friends want a shared world and nothing else. There's less to break, less to update, less to think about.
- Testing what a vanilla client is going to see, without any of the small changes plugin servers introduce.
Datapacks have grown up a lot since 1.13. You can add crafting recipes, custom advancements, loot tables, dimensions and quite a bit of gameplay with them alone. For some servers, that's genuinely enough.
Where vanilla runs out of room is anything that needs plugin-level control: permissions, world protection, custom economies, anti-cheat, and the performance settings Paper exposes.
Where Paper sits
Paper is a fork of Spigot, which is itself a fork of CraftBukkit. It keeps the same plugin API as Bukkit and Spigot, so most plugins you find on Modrinth, Hangar or SpigotMC just work. On top of that, Paper changes a lot of small things in the server to run faster and to expose more knobs.
A short list of what Paper does differently from vanilla:
- Async chunk loading and saving, so the main thread doesn't stall waiting on disk.
- A rewritten light engine tuned for large worlds.
- Configurable mob spawn limits per chunk, per world and per mob category.
- Entity activation ranges, so mobs far from any player stop ticking.
- Anti-xray, which can hide ores from clients that try to peek at the world data.
- Hundreds of settings in paper-global.yml and paper-world-defaults.yml that let you trade behaviour for TPS.
The tick loop is still single-threaded. Paper is faster than vanilla on the same hardware, but there is one main thread doing the world work. If you fill that thread up with too many entities, too many hoppers, or a very active nether portal, TPS still falls.
Paper is what almost every plugin-based server runs. If you want LuckPerms, WorldGuard, CoreProtect, an economy plugin and a shop plugin, Paper is the sensible base. Its downstream forks like Purpur and Pufferfish push different tradeoffs on top, but they inherit Paper's plugin API and design.
What Folia actually changes
Folia is a fork of Paper by the PaperMC team. It doesn't just tune the existing loop, it rewrites how the world is ticked. Instead of one main thread, Folia divides the world into regions, and each region ticks independently on its own thread. A region is a contiguous group of chunks the server groups together based on where players are and how loaded chunks connect.
The practical effect: two regions far apart in the world can tick in parallel on different cores. If one region has 40 players fighting in a raid, that work happens on one thread. If another region on the other side of the map has a redstone farm running, that runs on a different thread. They don't block each other.
That's the good part. The catch is that Folia breaks assumptions almost every Paper plugin makes.
On Paper, plugins can call almost any API from the main thread and expect it to work. Player data, world data, entities, block updates: it's all one thread, so it's all safe. On Folia, "the main thread" isn't really a thing anymore. A plugin that grabs a player, walks over to a chunk far away and modifies a block there is crossing between regions, and Folia won't let it do that the way Paper would.
Folia introduces a set of schedulers: a global region scheduler for world-wide work, a region scheduler tied to a location, an entity scheduler tied to a specific entity, and an async scheduler for off-thread work. Plugins have to be written or updated to use those schedulers instead of the classic Bukkit scheduler. Many plugins have not been.
When Folia earns its keep
Folia was built for a specific shape of server: many players, spread out. The clearer the separation between what players are doing, the more Folia has to work with.
Servers where it lines up well:
- Skyblock and similar island servers. Each player or team has their own island far from every other island, and each island can tick on its own thread. This is close to the ideal case.
- Large survival servers where the player base is spread across a big map. Different bases, different biomes, different mob farms, all ticking without blocking each other.
- Some minigame networks where the game world for each match is genuinely separate from the others. Not every network fits this, but the ones that do gain a lot.
- Anarchy servers with high player counts and no central hub, where the population isn't concentrated in a small area.
The common thread is distance. Folia thrives when the work happens in different regions. Players a few hundred blocks apart still get grouped into the same region, so "spread out" here means map-scale distance, not just standing in different rooms of the same base.
When Paper is still the right call
Paper is the right pick for most servers, and it isn't close.
Situations where Folia has little to offer:
- Hub servers and lobbies where every player is in the same area. There's only one region doing real work, so extra threads don't help.
- Small SMPs. A ten-player survival server on a decent CPU is nowhere near saturating one core's tick budget. Folia's complexity buys nothing here.
- Servers that depend on plugins not yet ported to Folia. If your setup needs a plugin that assumes the classic Bukkit scheduler, and no Folia-compatible fork exists, Folia is a dead end until that changes.
- Anything that leans hard on cross-region behaviour, like teleport-heavy game modes that constantly move players between distant places. Cross-region work still costs, and if most of your ticks are doing that, you lose the benefit of the split.
- Servers whose bottleneck is chunk generation, disk I/O or network, not the tick loop. Folia parallelises ticking. It doesn't magically make world gen faster.
There's also the question of plugin availability. Paper has thousands of plugins that have been tested and maintained for years. Folia has a smaller, growing set: some plugins have official Folia support, some have community forks, some have neither. Before switching, check every plugin on your server, not just the big ones.
How to think about the choice
A rough decision path that fits most servers:
- Small group, no plugins wanted, want exact vanilla behaviour: vanilla.
- Plugin-based server, one to a few hundred players, any shape: Paper.
- High player count, players naturally spread across a big or partitioned world, and every plugin you need has Folia support: consider Folia.
TPS problems don't automatically mean you need Folia. Most laggy servers are held back by one big farm, one badly written plugin, one overloaded chunk, or JVM flags that don't fit the RAM. Fixing those with Paper's existing settings, a profiler like Spark, and better JVM args usually recovers more TPS than a switch to Folia ever would, and it doesn't cost you plugin compatibility.
If tick timing on a single region really is your ceiling, and your world is shaped like Folia expects, then it starts to make sense. That's a real but narrow set of servers.
A note on where the ecosystem is going
The PaperMC team develops Paper and Folia in parallel. Paper gets performance work and new API on every Minecraft version. Folia gets the same base plus its regionised threading, and its API is stabilising as more plugins target it. The distance between them will probably shrink over time as more plugins publish Folia-ready builds, but the design intent stays the same: Paper for one main thread done well, Folia for many regions done in parallel.
For most people reading this, Paper is still the answer. Vanilla is a real choice if you want the game exactly as shipped. Folia is a real choice if your server is genuinely built like Folia expects, and you've checked that your plugins are coming with you.
If you'd rather not run the server yourself, ChunkPod is a Minecraft host in early access. You can join the waitlist at chunkpod.com to get notified when hosting opens, and the free JVM Arguments Generator at chunkpod.com/tools can size startup flags for a Vanilla, Paper, Forge or Fabric server in the meantime.