Minecraft Server Lag: How to Fix TPS Drops

Your Minecraft server is stuttering. Players are complaining about block lag, mobs freezing in place, and redstone circuits misfiring. The problem is almost always the same thing - your TPS is dropping below 20.

TPS stands for Ticks Per Second. Minecraft servers run on a game loop that should execute exactly 20 ticks every second. Each tick handles mob AI, block updates, chunk loading, player interactions, and everything else that keeps the world running. When your server can't keep up, TPS drops and everything starts lagging.

This is not the same as FPS lag or network latency. TPS lag is server-side, and it affects every player connected to your server at once. A player with a 1000 Mbps connection still experiences TPS lag - it has nothing to do with their internet speed.

How to Check Your TPS

Before you start fixing things, you need to know where you stand. On most servers running Spigot, Paper, or Purpur, type /tps in the console or in-game chat. You will see three numbers representing the average TPS over the last 1, 5, and 15 minutes.

• 20 TPS - Perfect. Your server is running at full speed.
• 18-19 TPS - Slight dips. Players probably won't notice.
• 15-17 TPS - Noticeable lag. Mobs stutter, block placement feels delayed.
• Below 15 TPS - Serious problems. The server is struggling to keep up.

For deeper analysis, install Spark - a profiling plugin that shows exactly which tasks are eating your tick time. It breaks down CPU usage per tick and lets you identify the worst offenders. Run /spark profiler start, let it run for 2-3 minutes during a lag period, then /spark profiler stop to get a full report.

The Most Common Causes of TPS Drops

1. Too Many Entities

Entities are the single biggest TPS killer on most servers. Every mob, dropped item, minecart, armor stand, and experience orb counts as an entity. Each one needs to be processed every tick.

A typical survival server with 20 players can easily accumulate thousands of entities across loaded chunks. Animal farms with hundreds of cows or chickens are a classic culprit. One Reddit post from a server admin showed 18,000 entities across 400 loaded chunks - that server was running at 8 TPS.

How to fix it:

• Set entity limits in bukkit.yml under spawn-limits. Reducing monsters from 70 to 40-50 and animals from 10 to 6-8 makes a noticeable difference.
• Enable per-player-mob-spawn in Paper's config to distribute mob spawning per player instead of globally. This prevents one player's area from consuming the entire mob cap.
• Use merge-radius in spigot.yml to combine nearby dropped items and experience orbs. Set item to 3.5 and exp to 4.0.
• Add a plugin like ClearLagg to periodically remove ground items and limit entity counts per chunk.
• Encourage players to keep animal farms small or use kill switches.

2. Chunk Loading and World Generation

Every time a player explores new terrain, the server has to generate new chunks from scratch. This involves noise calculations, structure placement, biome blending, and decoration. On Paper and its forks, chunk loading happens asynchronously, which greatly reduces main thread impact. But on vanilla, Spigot, or Fabric, chunk loading still hits the main thread hard.

If you're not on Paper, open server.properties and set sync-chunk-writes=false. This alone can noticeably improve TPS on non-Paper servers by moving chunk saves off the main thread.

How to fix it:

• Pre-generate your world using Chunky. This front-loads the generation work. Set a world border first so you know your target radius.
• Set a world border to prevent players from exploring endlessly. A 10,000 block radius gives plenty of space (that's over 300 km² of explorable area) without letting the world grow out of control.
• In spigot.yml, adjust view-distance down from the default 10 to 6-8. This reduces how many chunks each player keeps loaded.
• In Paper's config, set simulation-distance to 3 or 4. Players can see further with view-distance, but only nearby chunks are simulated. This is one of the most impactful settings for performance.

3. Redstone and Hoppers

Redstone contraptions and hopper systems are another major source of TPS drain. Every active redstone circuit triggers block updates that cascade through neighboring blocks. Hoppers are especially bad because they check for items above them every tick by default.

A single hopper chain of 100 hoppers running constantly can eat a measurable chunk of your tick budget. Servers with large automated farms often see hopper lag as their primary problem after fixing entities.

How to fix it:

• In Paper's config, set hopper.disable-move-event to true. This skips the InventoryMoveItemEvent for hoppers and dramatically improves performance on servers with heavy hopper use.
• Increase ticks-per.hopper-transfer and ticks-per.hopper-check in spigot.yml. Raising these from 8 to 16 makes hoppers slightly slower but halves the processing overhead.
• Consider using alternatives to large hopper systems. Water streams feeding into a single collection hopper are much more efficient than 50-hopper chains.

4. Plugins and Datapacks

Every plugin you install runs code on the server's main thread. Poorly written plugins, plugins that run heavy database queries synchronously, or simply having too many plugins all contribute to TPS drops.

How to fix it:

• Use Spark's profiler to identify which plugins consume the most tick time. Run the profiler during a lag event, not during idle time.
• Remove plugins you are not using. Every plugin adds overhead even when idle, particularly those that register event listeners.
• Check if plugins have async options for heavy operations. A plugin querying a MySQL database on the main thread will freeze the entire server during that query.
• Keep plugins updated. Developers often fix performance issues in newer versions.
• Watch out for anti-cheat plugins on small servers - some are notoriously heavy and not worth the overhead for a private community server.

5. Insufficient Hardware and JVM Configuration

Sometimes the server just doesn't have enough power. Minecraft is single-threaded for its main game loop, which means single-thread clock speed matters far more than core count. A 4-core processor at 5.0 GHz will outperform a 16-core server at 2.5 GHz for Minecraft.

RAM matters too, but not in the way most people think. Over-allocating RAM causes longer garbage collection pauses, which show up as lag spikes. For a server with 20 players, 4-6 GB is usually enough. For 50+ players, 8-10 GB.

Aikar's JVM flags dramatically reduce garbage collection lag. Use these flags when starting your server:

java -Xms6G -Xmx6G -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 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -jar server.jar nogui

These flags tune Java's G1 garbage collector for Minecraft's memory usage pattern. Most lag spikes on otherwise well-configured servers are GC-related, and these flags fix that.

Other hardware fixes:

• Use SSDs for server storage. Chunk loading from a spinning hard drive is painfully slow and shows up directly as TPS drops during exploration.
• Choose a hosting provider that uses high clock speed CPUs. Single-thread performance is everything for Minecraft.

Server Software Matters

If you are still running vanilla Minecraft server software, you are leaving significant performance on the table. Paper (and its fork Purpur) include dozens of optimizations that significantly improve TPS without changing gameplay.

The performance difference is substantial. Paper can handle 2-3x more players than vanilla at the same TPS level. It includes async chunk loading, optimized entity ticking, faster redstone processing, and many other improvements that vanilla simply does not have.

Recommended server software:

1. Paper - The standard choice for any serious server. Drop-in replacement for Spigot with major performance improvements.
2. Purpur - Fork of Paper with additional configuration options and quality-of-life tweaks for server admins.
3. Folia - Mojang-supported multithreaded fork for very large servers (100+ players). Still maturing but promising for high player counts.

Avoid anything claiming "async everything" or miracle performance - those are usually scams or poorly coded.

Quick Optimization Checklist

Here is a summary of the most impactful changes you can make:

Keep Your Server Running Smooth

TPS drops are frustrating, but they are almost always fixable. Start by profiling with Spark to find the real bottleneck. Then work through the fixes above, starting with entities and chunk loading since those are the most common culprits. Apply the JVM flags - that alone fixes a surprising number of lag spike complaints.

If you are looking for Minecraft hosting that gives you the CPU power and SSD storage to keep your TPS at a solid 20, check out DoomHosting's Minecraft server hosting. We run high clock speed processors optimized for single-threaded workloads, which is exactly what Minecraft needs to stay at a stable 20 TPS.