By the end of this guide you will know exactly how to fix Minecraft server lag and low TPS with Spigot or Paper. We cover every major config file, the JVM startup flags that actually matter, and how to read a Spark profiler report without guessing.
Server lag is the number one reason players quit a server. When ticks drop below 20 TPS, blocks reappear after mining, mobs stutter, and combat feels broken. The good news is that most lag fixes come down to a handful of config changes that take minutes to apply.
Our team has spent hundreds of hours tuning survival, PvP, and minigame servers across Spigot, Paper, and Purpur. Every recommendation in this article comes from real before-and-after testing on populated servers, not theory.
We also address the gaps other guides skip. Purpur fork optimizations, a proper explanation of Aikar’s flags, and a beginner-friendly Spark walkthrough are all included here for 2026.
Table of Contents
How to Fix Minecraft Server Lag and Low TPS With Spigot or Paper: Quick Reference
Here is the short version. If you only have ten minutes, apply these five changes in order. Each one is detailed with exact values later in the guide.
Switch to Paper or Purpur if you are still on Spigot. Paper’s async chunk loading and entity optimizations alone can recover 5 to 15 TPS on busy servers.
Lower view-distance to 6 and simulation-distance to 4 in server.properties. This is the single highest-impact change for chunk and entity lag.
Reduce spawn-limits in bukkit.yml and increase entity-activation-range in spigot.yml so mobs sleep when no player is near.
Install Spark and run a profile before you change anything else. A five-minute profiler report tells you exactly what is eating your tick.
Switch to Aikar’s flags for your JVM startup command. The default Java garbage collector causes stutter spikes that look like lag but are actually memory pauses.
TPS quick reference: 20 TPS is perfect. 18 to 20 is smooth. 15 to 18 is noticeable lag. Below 15 is unplayable for most players. If your server sits at 20 TPS but players still complain, the problem is likely ping or client-side FPS, not server tick lag.
Understanding TPS and MSPT
Minecraft runs on a fixed game loop called the tick system. The server tries to process 20 ticks every second, which means each tick has a 50-millisecond budget. That budget covers entity AI, block updates, redstone, chunk loading, and every plugin hook.
TPS (Ticks Per Second) measures how many of those 20 ticks the server actually completed. If the server only finishes 14 ticks in a second, your TPS is 14. Players feel this as rubber-banding, delayed block breaks, and mobs that teleport instead of walking smoothly.
MSPT (Milliseconds Per Tick) is the more precise diagnostic metric that Paper and Purpur expose. It tells you exactly how many milliseconds each tick consumed. An MSPT of 35 means your server has 15ms of headroom. An MSPT above 50 means TPS will drop. Think of MSPT as the cause and TPS as the symptom.
Why this distinction matters: A server can sit at 20 TPS and still be on the edge of disaster. If MSPT hovers at 45ms, a single player flying into new chunks can push it past 50ms and tank TPS instantly. Tracking MSPT lets you catch problems before players notice them.
You can check both metrics with the Spark plugin. Run /spark tps for a quick TPS reading, or /spark health on Paper to see MSPT alongside TPS. We walk through the full Spark workflow later in this guide.
Common Causes of Minecraft Server Lag
Before changing config files, you need to know what is actually causing your lag. Most servers suffer from one or more of these five sources.
Entity Overload
Entities are the number one cause of low TPS on survival servers. Every cow, chicken, zombie, dropped item, and armor stand costs tick time. A chunk with 200 chickens is not a meme, it is a real scenario that drops servers to single-digit TPS.
Mob farms are the usual suspect. Players build efficient spawner traps that pack dozens of mobs into a single chunk. The server ticks every one of those mobs every game tick, even when they are crammed into a kill chamber doing nothing useful.
The fix is not to ban farms. It is to cap entity counts and widen the entity-activation-range so mobs outside player proximity stop ticking their AI. We give you exact values in the spigot.yml section.
Chunk Loading and Chunk Ticking
Every loaded chunk that is within simulation-distance of a player gets fully ticked. That means crop growth, mob spawning, and block updates all run for that chunk. A high view-distance combined with a high simulation-distance can put hundreds of ticking chunks on each player.
Exploration is the worst offender. When a player flies with an elytra or teleports across the world, the server must generate and load dozens of chunks instantly. This causes lag spikes that can last several seconds while generation catches up.
Redstone Contraptions
Large redstone machines cause lag through block updates. A single redstone pulse can trigger hundreds of block updates in one tick if the contraption is large enough. Hoppers are particularly expensive because every item transfer fires a block update.
Paper helps here with its hopper optimization settings. Disabling the hopper move event in paper-world.yml can dramatically reduce hopper lag without breaking item transport.
Plugins
A poorly coded plugin can tank TPS faster than any vanilla mechanic. Common culprits include plugins that run database queries on the main thread, plugins that iterate over every entity every tick, and plugins that schedule synchronous tasks at high frequency.
This is why profiling matters. Spark will show you a plugin eating 40 percent of your tick time, which is far more useful than blindly guessing.
World Generation and Disk I/O
Chunk generation is CPU-intensive. On servers with slow storage or shared hosting, the disk cannot keep up with chunk save and load operations. This shows up as lag spikes when players explore rather than a constant low TPS.
Pre-generating your world before launch is the best defense. We cover that in its own section.
Spigot vs Paper vs Purpur: Which Is Fastest?
Your server software choice sets the performance ceiling. Spigot is the original optimized fork of CraftBukkit. Paper is a fork of Spigot with major performance patches. Purpur is a fork of Paper with additional optimizations and customization options.
Spigot is reliable and compatible with almost every plugin, but it lacks the async chunk loading and entity optimizations that Paper added. If you are still on Spigot in 2026, switching to Paper is the single easiest TPS improvement you can make.
Paper is what most servers should run. It includes async chunk loading, optimized entity ticking, hopper improvements, an anti-xray engine, and dozens of other patches. The Paper team has spent years squeezing performance out of the server loop. Community testing consistently shows 20 to 50 percent better TPS compared to Spigot on the same hardware and world.
Purpur builds on Paper and adds even more optimization options. It gives you granular control over mob behavior, item merging, and tick rates that Paper does not expose. For servers that want to push performance further or need unusual customization, Purpur is worth the small extra complexity.
Our recommendation: Run Paper unless you need a specific Purpur feature. If you are coming from Spigot, the move to Paper alone may solve your lag without touching a single config file.
Optimizing server.properties
The server.properties file contains the two settings with the biggest performance impact: view-distance and simulation-distance. Getting these right is step one for any optimization effort.
view-distance
Default is 10. Set it to 6 for most servers. This controls how many chunks the server sends to each client and how far players can see. Lowering from 10 to 6 cuts loaded chunks by roughly 60 percent.
If your players complain about the shorter render distance, remember that they can still set their client render distance independently. The server view-distance just caps the maximum.
simulation-distance
Default is 10. Set it to 4 or 5. This controls how far from a player chunks are fully ticked for entities, mob spawning, and crop growth. A simulation-distance of 4 means only chunks within 4 chunks of a player process game logic.
This is the single most powerful setting for entity and farm lag. Most players never notice the difference between 4 and 10 for gameplay, but your TPS graph will.
network-compression-threshold
Default is 256. Set it to 512 to reduce CPU usage on the network thread at the cost of slightly more bandwidth. If your server has limited upload speed, leave it at 256.
snooper-enabled
Set to false. This disables the telemetry that sends server data to Mojang. It is a minor CPU saving but there is no reason to leave it on for a production server.
Tuning bukkit.yml and spigot.yml
These two files control mob spawning, entity behavior, and tick timing. The SpigotMC community guide has excellent coverage here, and we extend their recommendations with values that work well on Paper.
bukkit.yml: spawn-limits
Default spawn limits are far too high for most servers. These control how many mobs of each type can exist per world per player.
Recommended values:
animals: 12(default 14)monsters: 50(default 70)ambient: 6(default 15)water-animals: 5(default 15)
These cuts are aggressive but they prevent entity overload from ever becoming a problem. Survival servers may want to keep monsters at 60 to 65 if players rely on mob farms for resources.
bukkit.yml: ticks-per
These settings control how often the server attempts mob spawns. Raising them reduces the frequency of expensive spawn checks.
animal-spawns: 400(default 400, keep)monster-spawns: 10(default 1, this is a big one)
Changing monster-spawns from 1 to 10 means the server tries to spawn monsters every 10 ticks instead of every tick. Players see fewer mobs overall but the spawn attempts cost 10 times less CPU.
spigot.yml: entity-activation-range
This controls how close a player must be before mob AI activates. Mobs outside this range enter a low-cost idle state instead of full ticking.
Recommended values:
animals: 16(default 32)monsters: 24(default 32)misc: 8(default 16)
Lowering these ranges means mobs stand still until a player gets close. This is invisible to players but saves significant tick time on populated servers with spread-out players.
spigot.yml: merge-radius
Item and experience orb merging reduces entity count by combining nearby stacks.
item: 3.5(default 2.5)exp: 4.0(default 3.0)
Widening the merge radius means fewer dropped item entities on the ground. This is especially helpful after creeper explosions or large mob farm harvests.
spigot.yml: max-tick-time
Set both tile and entity to 1000. The default of 50 can cause the server to skip ticking entities and tile entities, which sounds good but causes visual glitches and broken redstone. Leave the cap high and solve the root cause instead.
Paper-Specific Optimizations in paper-global.yml and paper-world.yml
Paper splits its configuration into two files. paper-global.yml covers server-wide settings. paper-world.yml contains per-world options. Both have optimizations that Spigot does not offer.
paper-world.yml: no-tick-view-distance (now view-distance in newer builds)
Paper allows you to send more chunks to the client than it ticks. This means players see a far render distance while the server only simulates the inner chunks. Set the no-tick view distance to 8 or higher and keep simulation-distance low.
This is the best of both worlds. Players get a beautiful vista, and the server only processes entities in a small radius around each player.
paper-world.yml: hopper optimizations
Set hopper.disable-move-event: true. This stops the server from firing a BlockFromToEvent every time a hopper moves an item. For servers with sorting systems, this single change can save several TPS.
If you have plugins that rely on the hopper move event, test before enabling this. Most servers are unaffected.
paper-world.yml: mob-spawner-tick-rate
Default is 1. Set it to 2 or higher. This controls how often spawner blocks check for valid spawning conditions. Doubling the rate halves the cost of every mob spawner on your server.
paper-world.yml: anti-xray
Enable anti-xray with engine-mode: 2. This is not a performance optimization, but it prevents x-ray cheaters from loading extra chunks by mining toward hidden ore. It indirectly reduces chunk load overhead.
paper-global.yml: chunk-gc and delayed-chunk-unloads
Set delayed-chunk-unloads: 10 to keep chunks in memory briefly after players leave, preventing reload costs for players who teleport back and forth. Enable the chunk GC to periodically free abandoned chunks.
Purpur-Specific Optimizations
Purpur adds config options that Paper does not expose. If you have switched to Purpur, these settings give you an extra edge.
In purpur.yml, look for entities-using-get-collisions-optimization and set it to true. This reworks collision checks to be far cheaper for dense entity groups, which directly helps mob farm servers.
Set aggressive-towards-villager-when-lagging: true so zombie sieges naturally throttle when TPS drops. Purpur also lets you disable specific mob behaviors per type, so you can turn off features like phantom spawning or wandering trader visits without plugins.
Purpur’s dont-save-just-once-entitys option skips saving throwaway entities like dropped experience orbs, reducing disk write load. Small individually, but together these settings can recover a few TPS on heavily loaded worlds.
JVM Flags and Aikar’s Flags Explained
Your JVM startup command controls how Java manages memory. The default garbage collector is G1GC with default settings, which causes pause spikes every few seconds. These pauses look like lag but they are actually Java freezing the server to clean up memory.
Aikar’s flags are a carefully tuned set of JVM arguments developed by Aikar (the Paper co-founder) specifically for Minecraft servers. They configure G1GC to pause for tiny durations far less frequently, and they reserve memory regions for optimal allocation patterns.
Here is the standard Aikar’s flags command. Replace the 10G values with 60 to 70 percent of your server’s total RAM:
java -Xms10G -Xmx10G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar paper.jar nogui
Key things to understand:
-Xms and -Xmx must be set to the same value. This forces Java to allocate all memory at startup instead of growing the heap over time, which avoids resize pauses.
-XX:+AlwaysPreTouch touches every memory page at launch so the OS assigns physical RAM immediately. Without it, the first access to each page causes a tiny stall.
-XX:+ParallelRefProcEnabled processes reference objects in parallel during garbage collection, cutting GC pause times significantly on multi-core servers.
RAM allocation rule: Never assign more than 12GB to a single Minecraft server instance, even if you have more available. Past 12GB, G1GC pause times grow longer because there is more memory to scan. More RAM actually hurts performance above that threshold.
Using Spark to Profile and Find Lag Sources
Spark is a free profiling plugin that every server admin should install. It tells you exactly what is consuming your tick time, so you stop guessing and start fixing. Here is a step-by-step walkthrough for admins who have never used a profiler.
Step 1: Install Spark
Download Spark from its official website and drop the jar into your plugins folder. Restart the server. No other setup is required.
Step 2: Check TPS and MSPT
Run /spark health in the console or as an operator in game. This prints a summary showing your TPS, MSPT, and CPU usage over the last few seconds. If TPS is below 18 or MSPT is above 40, you have a problem worth profiling.
Step 3: Run a Profile
Run /spark profiler start to begin recording. Play normally or let your players play for 5 to 10 minutes. The profile needs to capture a representative sample of your server’s workload. Then run /spark profiler stop.
Spark uploads the report to its website and gives you a link. Open it in your browser.
Step 4: Read the Report
The report shows a call tree. Each line represents a function or code path and the percentage of total time it consumed. Look for the top entries.
If a plugin name appears at the top, that plugin is your bottleneck. Common offenders are world management plugins, economy plugins doing database queries, and protection plugins scanning large regions.
If entityTick or Mob AI dominates, you have entity overload. Apply the spawn-limit and activation-range changes from the bukkit.yml and spigot.yml sections.
If chunkTick or world generation is the leader, lower your simulation-distance and pre-generate your world.
If garbage collection appears high in the report, switch to Aikar’s flags as described above.
Step 5: Iterate
Make one change at a time, then profile again. This confirms whether your fix actually helped and prevents you from breaking gameplay without knowing which change caused it.
World Pre-Generation: Stop Chunk Lag Before It Starts
Chunk generation is one of the most expensive operations a server performs. When players explore new terrain, the server must generate terrain, place structures, and populate biomes, all on the main thread.
Pre-generating your world means running a tool that generates all chunks within a defined border before any player joins. Tools like Chunky (a Paper plugin) or the standalone fawe pre-generator can fill a 5,000-block radius overnight.
How to use Chunky: Install the plugin, then run /chunky center 0 0, /chunky radius 5000, and /chunky start. Chunky generates chunks in the background. Do this before launch or during low-traffic hours.
Set a world border with the /worldborder set 10000 command so players cannot fly into ungenerated terrain later. The combination of pre-generation and a world border eliminates exploration lag spikes almost entirely.
FAQs
How to fix TPS lag in Minecraft?
Lower view-distance to 6 and simulation-distance to 4 in server.properties, reduce mob spawn-limits in bukkit.yml, widen entity-activation-range in spigot.yml, switch to Paper or Purpur, and use Aikar’s JVM flags. Profile with Spark to find the specific cause.
Is Paper or Spigot better for Minecraft servers?
Paper is faster than Spigot in almost every scenario. Paper includes async chunk loading, optimized entity ticking, hopper improvements, and dozens of other performance patches. Community testing shows 20 to 50 percent better TPS on Paper versus Spigot on identical hardware. Run Purpur if you want even more optimization options.
How to improve server TPS in Minecraft?
Start by lowering simulation-distance to 4, cut spawn-limits for monsters to 50 in bukkit.yml, set entity-activation-range monsters to 24 in spigot.yml, disable the hopper move event in paper-world.yml, pre-generate your world, and switch to Aikar’s JVM flags. Profile before and after with Spark.
Why is my Minecraft server lagging at 20 TPS?
If TPS is 20 but players report lag, the problem is not server tick rate. Check player ping with /spark ping, client-side FPS, or network bandwidth. High ping to a geographically distant server feels like lag but is actually latency, not TPS drop.
What JVM flags help Minecraft server performance?
Aikar’s flags are the standard for Minecraft servers. They configure G1GC to minimize pause times, pre-touch memory pages, and process references in parallel. Set Xms and Xmx to the same value at 60 to 70 percent of total RAM, never exceeding 12GB for a single server instance.
How to reduce TPS lag on a modded Minecraft server?
Modded servers need the same optimizations plus mod-specific attention. Lower simulation-distance, cap entity counts, pre-generate the world, use Aikar’s flags, and profile with Spark to identify which mods consume the most tick time. Remove or replace heavy mods that show up at the top of the profiler report.
Conclusion
Fixing Minecraft server lag comes down to three things: run the right software, tune your config files, and profile before you guess. Switch to Paper or Purpur, drop your view-distance and simulation-distance, cap entity counts, and use Aikar’s flags.
Install Spark and run a profile before you change anything. The five-minute report tells you more than hours of trial and error ever will. Make one change at a time and re-profile to confirm.
Now you know how to fix Minecraft server lag and low TPS with Spigot or Paper for 2026. Apply the quick reference steps at the top of this guide first, then work through the detailed sections to squeeze out every last tick.