Tools / Utilities

Minecraft Server Software Comparison

Compare Minecraft server software side by side: Vanilla, Paper, Purpur, Spigot, Fabric, Forge, NeoForge, Velocity and BungeeCord. Filter by plugins, mods or proxies and see what each one is for.

Filters

Game servers run the world. Proxies sit in front of several servers and move players between them

Plugins run on the server only. Most mods also need to be installed by every player

Turn software on or off to narrow the table

Comparison

SoftwarePluginsModsPlayers needPerformanceBest forConfig tools
VanillaServerMojang's official server.jarNoneNone (data packs only)A normal clientThe baseline. No performance patches and few settings beyond server.propertiesSmall groups who want the game exactly as Mojang ships it
PaperServerBegan as a Spigot fork, now developed on its ownBukkit, Spigot and Paper pluginsNoneA normal clientThe fastest mainstream plugin server: async chunk loading, many patches and tuning optionsMost plugin servers
PurpurServerFork of PaperBukkit, Spigot and Paper pluginsNoneA normal clientAbout the same as Paper, which it builds onPlugin servers that want gameplay settings Paper does not have
SpigotServerFork of CraftBukkit, built with BuildToolsBukkit and Spigot pluginsNoneA normal clientFaster than Vanilla, slower than Paper. Fewer patches and settingsPlugins that only run on Spigot, and behavior closer to Vanilla
FabricServerLightweight mod loader on the vanilla serverNoneFabric mods (most need Fabric API)Fabric and the same content mods. Server-side mods need nothingLight loader. Server-side mods such as Lithium and FerriteCore make it fastModern modpacks, and Vanilla with performance mods
ForgeServerThe original Minecraft mod loaderNoneForge mods (the largest library, most of it for older versions)Forge and the same modsHeavier loader. Large packs take minutes to start and need more RAMLarge modpacks, especially on 1.20.1 and older
NeoForgeServerFork of Forge from 2023NoneNeoForge mods (Forge mods on 1.20.1 only)NeoForge and the same modsSimilar to Forge. Memory use depends on the pack more than the loaderLarge modpacks on 1.20.2 and newer
VelocityProxyProxy written from scratch by the PaperMC teamVelocity plugins (not BungeeCord plugins)None. Can forward modded players to Forge and Fabric serversA normal clientHandles many players per core. Modern forwarding sends player data with a shared secretNew networks of several servers
BungeeCordProxyThe original proxy by md_5, the Spigot authorBungeeCord plugins (Waterfall plugins too)NoneA normal clientFine for most networks. IP forwarding has no secret, so backends must be firewalledExisting networks and plugins that only exist for BungeeCord
server-software-comparison.md · 202 lines
# Minecraft server software comparison

Type: Servers and proxies. Runs: Plugins, mods or neither.

| Software | Type | Plugins | Mods | Best for |
| --- | --- | --- | --- | --- |
| Vanilla | Server | None | None (data packs only) | Small groups who want the game exactly as Mojang ships it |
| Paper | Server | Bukkit, Spigot and Paper plugins | None | Most plugin servers |
| Purpur | Server | Bukkit, Spigot and Paper plugins | None | Plugin servers that want gameplay settings Paper does not have |
| Spigot | Server | Bukkit and Spigot plugins | None | Plugins that only run on Spigot, and behavior closer to Vanilla |
| Fabric | Server | None | Fabric mods (most need Fabric API) | Modern modpacks, and Vanilla with performance mods |
| Forge | Server | None | Forge mods (the largest library, most of it for older versions) | Large modpacks, especially on 1.20.1 and older |
| NeoForge | Server | None | NeoForge mods (Forge mods on 1.20.1 only) | Large modpacks on 1.20.2 and newer |
| Velocity | Proxy | Velocity plugins (not BungeeCord plugins) | None. Can forward modded players to Forge and Fabric servers | New networks of several servers |
| BungeeCord | Proxy | BungeeCord plugins (Waterfall plugins too) | None | Existing networks and plugins that only exist for BungeeCord |

## Vanilla

- Type: Game server
- Based on: Mojang's official server.jar
- Plugins: None
- Mods: None (data packs only)
- Players need: A normal client
- Performance: The baseline. No performance patches and few settings beyond server.properties
- Config files: server.properties

Use it for:

- A few friends playing unmodified survival
- Technical players whose farms depend on exact vanilla mechanics
- Playing a new version on release day, before other software updates

Config generators:

- https://chunkpod.com/tools/server-properties

## Paper

- Type: Game server
- Based on: Began as a Spigot fork, now developed on its own
- Plugins: Bukkit, Spigot and Paper plugins
- Mods: None
- Players need: A normal client
- Performance: The fastest mainstream plugin server: async chunk loading, many patches and tuning options
- Config files: server.properties, bukkit.yml, spigot.yml, paper-global.yml, paper-world-defaults.yml

Use it for:

- Survival and SMP servers with plugins such as LuckPerms and EssentialsX
- Minigame and lobby servers behind Velocity
- Any server where performance matters more than exact vanilla mechanics

Config generators:

- https://chunkpod.com/tools/server-properties
- https://chunkpod.com/tools/bukkit-yml
- https://chunkpod.com/tools/spigot-yml
- https://chunkpod.com/tools/paper-yml

## Purpur

- Type: Game server
- Based on: Fork of Paper
- Plugins: Bukkit, Spigot and Paper plugins
- Mods: None
- Players need: A normal client
- Performance: About the same as Paper, which it builds on
- Config files: server.properties, bukkit.yml, spigot.yml, paper-global.yml, paper-world-defaults.yml, purpur.yml

Use it for:

- SMPs that want rideable mobs, tweaks to villagers or phantoms and similar options without extra plugins
- Paper servers that need one gameplay change Paper will not add

Config generators:

- https://chunkpod.com/tools/server-properties
- https://chunkpod.com/tools/bukkit-yml
- https://chunkpod.com/tools/spigot-yml
- https://chunkpod.com/tools/paper-yml

## Spigot

- Type: Game server
- Based on: Fork of CraftBukkit, built with BuildTools
- Plugins: Bukkit and Spigot plugins
- Mods: None
- Players need: A normal client
- Performance: Faster than Vanilla, slower than Paper. Fewer patches and settings
- Config files: server.properties, bukkit.yml, spigot.yml

Use it for:

- Running a plugin that breaks on Paper
- Plugin servers that want fewer changes to vanilla mechanics than Paper makes

Config generators:

- https://chunkpod.com/tools/server-properties
- https://chunkpod.com/tools/bukkit-yml
- https://chunkpod.com/tools/spigot-yml

## Fabric

- Type: Game server
- Based on: Lightweight mod loader on the vanilla server
- Plugins: None
- Mods: Fabric mods (most need Fabric API)
- Players need: Fabric and the same content mods. Server-side mods need nothing
- Performance: Light loader. Server-side mods such as Lithium and FerriteCore make it fast
- Config files: server.properties, config/ (one file per mod)

Use it for:

- Light and mid-size modpacks on recent Minecraft versions
- Vanilla-feeling servers with server-side performance mods
- Updating to a new Minecraft version soon after release

Config generators:

- https://chunkpod.com/tools/server-properties

## Forge

- Type: Game server
- Based on: The original Minecraft mod loader
- Plugins: None
- Mods: Forge mods (the largest library, most of it for older versions)
- Players need: Forge and the same mods
- Performance: Heavier loader. Large packs take minutes to start and need more RAM
- Config files: server.properties, user_jvm_args.txt, config/ (one file per mod)

Use it for:

- Kitchen-sink modpacks such as All the Mods 9 and RLCraft
- Classic packs on 1.12.2, 1.16.5 and 1.18.2

Config generators:

- https://chunkpod.com/tools/server-properties
- https://chunkpod.com/tools/jvm-arguments

## NeoForge

- Type: Game server
- Based on: Fork of Forge from 2023
- Plugins: None
- Mods: NeoForge mods (Forge mods on 1.20.1 only)
- Players need: NeoForge and the same mods
- Performance: Similar to Forge. Memory use depends on the pack more than the loader
- Config files: server.properties, user_jvm_args.txt, config/ (one file per mod)

Use it for:

- New modpacks for 1.21, where most large mods moved to NeoForge
- Mods that dropped Forge support after the split

Config generators:

- https://chunkpod.com/tools/server-properties
- https://chunkpod.com/tools/jvm-arguments

## Velocity

- Type: Proxy
- Based on: Proxy written from scratch by the PaperMC team
- Plugins: Velocity plugins (not BungeeCord plugins)
- Mods: None. Can forward modded players to Forge and Fabric servers
- Players need: A normal client
- Performance: Handles many players per core. Modern forwarding sends player data with a shared secret
- Config files: velocity.toml, forwarding.secret

Use it for:

- Linking a lobby, survival and minigame servers behind one address
- Networks of Paper servers using modern forwarding

Config generators:

- https://chunkpod.com/tools/velocity-config
- https://chunkpod.com/tools/paper-yml

## BungeeCord

- Type: Proxy
- Based on: The original proxy by md_5, the Spigot author
- Plugins: BungeeCord plugins (Waterfall plugins too)
- Mods: None
- Players need: A normal client
- Performance: Fine for most networks. IP forwarding has no secret, so backends must be firewalled
- Config files: config.yml

Use it for:

- Networks already built on BungeeCord or Waterfall
- Networks that depend on a BungeeCord-only plugin

Config generators:

- https://chunkpod.com/tools/bungeecord-config
- https://chunkpod.com/tools/spigot-yml

Which Minecraft server software should you use?

Minecraft server software decides what your server can load and how well it runs. This comparison covers the nine options most admins choose between: Vanilla, Paper, Purpur, Spigot, Fabric, Forge, NeoForge, Velocity and BungeeCord. The table above shows what each one runs, what players need on their side, how it performs and what it is best at. Filter it by plugins, mods or proxies, or load one of the "vs" presets to put two options side by side.

The short answer for most people:

  • You want plugins (permissions, economy, land claims, minigames): use Paper.
  • You want mods (new blocks, machines, dimensions): use NeoForge for modpacks on 1.21, Forge for packs on 1.20.1 and older, or Fabric for lighter packs and performance mods.
  • You want the game exactly as Mojang made it with a few friends: Vanilla is fine.
  • You want several servers behind one address: put Velocity in front of them.

The rest of this page explains the choices behind those answers, and the three comparisons people search for most: Paper vs Spigot, Fabric vs Forge, and Velocity vs BungeeCord.

Game servers and proxies

The first split is between software that runs a world and software that does not.

A game server (Vanilla, Paper, Purpur, Spigot, Fabric, Forge, NeoForge) loads the world, ticks mobs and redstone, and saves chunks to disk. Players connect to it and play.

A proxy (Velocity, BungeeCord) has no world. It accepts player connections and passes them on to one or more game servers behind it, so a network can have a lobby, a survival server and a minigame server under one address. Players switch between them with a command or a portal without disconnecting. A proxy always runs next to game servers, never instead of one.

If you run a single server, you do not need a proxy. Set the "Type" filter to "Game servers" and ignore the last two rows.

Plugins or mods

The second split is how the server gets new features.

Plugins run only on the server. They use an API (Bukkit, Spigot or Paper for game servers, and a separate API for each proxy) to react to events: a player joins, a block breaks, a command is typed. They can add commands, permissions, economies, protection and minigames, but they cannot add new blocks or items that the client does not already know about. Because nothing changes on the client, players join with a normal, unmodified game.

Mods change the game itself. They can add new blocks, mobs, dimensions and machines. Content mods have to be installed on both sides, so every player needs the same mod loader and the same mods as the server. That is why modded servers usually publish a modpack that players install through a launcher such as CurseForge, Modrinth or Prism. Some mods only change the server (performance mods like Lithium, for example), and those need nothing from players.

The two do not mix well. Plugin servers cannot load mods and mod loaders cannot load plugins. Hybrid projects such as Mohist and Arclight try to run Forge mods and Bukkit plugins together, but plugins that reach into game internals often break on them and mod authors rarely support them. Pick one side for a new server.

The 10 best Minecraft plugins and 10 best Minecraft mods posts show what each side offers if you are still deciding.

Paper vs Spigot

Paper and Spigot run the same plugins, so this is the most common question for plugin servers.

Spigot is a fork of CraftBukkit, the original plugin server. It added performance settings and its own plugin API on top of Bukkit. You cannot download a Spigot jar from SpigotMC. You build it yourself with BuildTools, which downloads the vanilla server and applies Spigot's patches.

Paper began as a fork of Spigot and since late 2024 has been developed on its own, without taking changes from Spigot. It still runs Bukkit and Spigot plugins, plus plugins written for Paper's own API. You download a ready-made jar from PaperMC.

Where they differ:

PaperSpigot
PluginsBukkit, Spigot and Paper pluginsBukkit and Spigot plugins
Getting the jarDownload from PaperMCBuild with BuildTools
PerformanceAsync chunk loading, many patches and settingsFewer optimizations
Config filesserver.properties, bukkit.yml, spigot.yml, paper-global.yml, paper-world-defaults.ymlserver.properties, bukkit.yml, spigot.yml
Vanilla behaviorFixes some exploits and duplication bugs by defaultCloser to Vanilla

For almost every server, Paper is the better choice. It loads chunks off the main thread, fixes known lag sources, and has settings for entity limits, despawn ranges, anti-xray and redstone that Spigot does not have. The Paper config generator writes both Paper files, and the spigot.yml generator and bukkit.yml generator cover the files Paper still reads from Spigot and Bukkit.

Spigot still makes sense in two cases. The first is a plugin that breaks on Paper, which is rare but happens with plugins that depend on exact Spigot internals. The second is a technical server whose farms rely on behavior Paper changes, such as TNT and rail duplication. Paper can turn most of those back on under unsupported-settings in paper-global.yml, so check that before switching.

Purpur sits one step further along. It is a fork of Paper, runs the same plugins, performs about the same, and adds a purpur.yml with hundreds of gameplay settings: rideable mobs, villager and phantom tweaks, and small quality-of-life changes that would otherwise need a plugin. Use Purpur if you want one of those settings. Otherwise Paper is the simpler choice, because it has the larger community and updates first.

The Paper vs Spigot vs Fabric vs Forge guide goes into more detail on each server type.

Fabric vs Forge vs NeoForge

These are the three mod loaders. The choice is usually made for you by the mods you want, because a mod is built for one loader.

Forge is the oldest loader and has the largest library of mods, most of it for older versions. Classic packs on 1.12.2, 1.16.5 and 1.18.2 are Forge packs, and so are big 1.20.1 packs such as All the Mods 9 and RLCraft on 1.12.2.

NeoForge split from Forge in 2023. On 1.20.1 the two are close enough that most Forge mods load on NeoForge. From 1.20.2 onwards they are separate loaders, and most large mods that update to new versions now target NeoForge. For a modpack on 1.21, NeoForge is usually the answer.

Fabric is a lighter loader that stays close to the vanilla code. It updates to new Minecraft versions quickly, starts faster and uses less memory than Forge for a similar number of mods. Most Fabric mods need Fabric API installed alongside them. Fabric is also popular for server-side mods that change nothing for players: Lithium (game logic), FerriteCore (memory) and Krypton (networking) make a Fabric server run faster while players still join with a vanilla client.

FabricForgeNeoForge
Mod libraryLarge, strongest on recent versionsLargest, strongest on 1.20.1 and olderGrowing, most large 1.21 mods
Startup and memoryLightestHeaviestSimilar to Forge
Players needFabric and the content modsForge and the modsNeoForge and the mods
Server-only modsCommon (Lithium, FerriteCore)SomeSome
Where to set RAMStart commanduser_jvm_args.txt (1.17+)user_jvm_args.txt

If your pack already exists, use the loader it was built for. Fabric and Forge mods do not load on each other's loader, and compatibility layers such as Sinytra Connector only cover some mods.

Modded servers need more memory than plugin servers, and big Forge and NeoForge packs need the most. The RAM calculator estimates the heap from the loader and mod count, and the JVM arguments generator writes the flags, including the user_jvm_args.txt lines Forge and NeoForge read.

Velocity vs BungeeCord

Both proxies link several game servers under one address. They are not compatible with each other's plugins, so the choice matters for which proxy plugins you can use.

BungeeCord is the original proxy, written by md_5, the author of Spigot. It has a large library of plugins built up over many years. Waterfall was a BungeeCord fork by the PaperMC team, and it reached end of life in 2024; its users are told to move to Velocity. BungeeCord itself is still updated.

Velocity is a proxy the PaperMC team wrote from scratch. It handles more players per CPU core, and its modern forwarding sends each player's real address and UUID to the backend servers signed with a shared secret. BungeeCord's IP forwarding has no secret: any client that can reach a backend server directly can claim to be any player. On BungeeCord you have to firewall the backends so only the proxy can reach them, or add a plugin such as BungeeGuard.

VelocityBungeeCord
PluginsVelocity pluginsBungeeCord and Waterfall plugins
Player forwardingModern forwarding with a secret (1.13+)IP forwarding, no secret
Backend settingproxies.velocity in paper-global.ymlbungeecord: true in spigot.yml
Config filevelocity.tomlconfig.yml
StatusMaintained by PaperMCMaintained by md_5

For a new network, use Velocity with Paper backends. Stay on BungeeCord if your network already runs on it and depends on plugins that have no Velocity version. Velocity can also use legacy BungeeCord forwarding, which lets you move the proxy first and switch the backends to modern forwarding later.

The Velocity config generator writes velocity.toml with the forwarding mode and server list, and the BungeeCord config generator writes BungeeCord's config.yml. For existing Waterfall networks, the Waterfall config generator covers both of its files.

Modded networks can run behind a proxy too, but Fabric, Forge and NeoForge backends need a mod such as FabricProxy-Lite or Proxy Compatible Forge to accept the forwarded player data.

When Vanilla is the right choice

Vanilla is Mojang's own server.jar. It has no plugins, no mods and only the settings in server.properties. It does support data packs, which can add recipes, advancements, loot tables and custom world generation.

It is a reasonable choice for a small group of friends who want the plain game, and for new versions on release day, before Paper and the mod loaders update. Technical players who build farms that depend on exact vanilla mechanics also often prefer it, although many run Fabric with Lithium instead, which keeps vanilla behavior and runs faster.

For anything beyond that, Paper usually runs the same world with less lag and adds the option of plugins later. Paper reads the same server.properties, so a server.properties file you generate for Vanilla works on Paper unchanged.

How to use the comparison tool

  1. Pick a preset for the question you have: "Paper vs Spigot", "Fabric vs Forge vs NeoForge", "Velocity vs BungeeCord", or the "Plugin Servers" and "Modded Servers" groups.
  2. Or set the filters yourself. "Type" limits the table to game servers or proxies. "Runs" limits it to software that runs plugins or mods. Vanilla only shows when "Runs" is set to "Plugins, mods or neither".
  3. Turn single entries on or off under "Software to Compare" to build your own comparison.
  4. Read across the table. "Players need" tells you whether players can join with a normal client, and "Config tools" links the generators for that software's files.
  5. Copy or download the comparison as Markdown to share it with your staff or paste it into a planning document.

Common mistakes

Picking by performance alone. Fabric with Lithium and Paper are both fast. The deciding question is whether you need plugins or mods, and then which ones.

Mixing plugins and mods. A plugin jar in a Forge mods folder does nothing, and a mod jar in a Paper plugins folder fails to load. Hybrid servers seem to solve this, then break on updates.

Running Spigot out of habit. Many older guides say Spigot. Unless one of your plugins needs it, Paper runs the same plugins with better performance.

Starting a new network on BungeeCord or Waterfall. Waterfall no longer gets updates, and BungeeCord's forwarding needs a firewall to be safe. Velocity is the better starting point.

Switching software without a backup. Paper and Spigot store the Nether and the End in separate folders (world_nether, world_the_end). They convert a Vanilla world on first start, but going back to Vanilla or a mod loader means moving those folders back by hand. Moving a modded world to Paper removes every modded block. Copy the whole server folder before switching.

Forgetting the players. A Forge or NeoForge server needs every player to install the same pack. For a public server where people join from a server list, that is a real barrier. Plugin servers have none.

Performance on any software

The software sets the ceiling, but most lag comes from what happens in the world: too many entities, big farms, unloaded chunks being generated while players explore. The server lag guide covers the usual causes. On any software, lowering view-distance and simulation-distance is the most effective single change; the view distance calculator suggests values for your RAM and player count. Pre-generating the world with Chunky removes most exploration lag on Paper and Fabric.