tpsserver-optimizationpaperspigotperformancelag

Minecraft Server TPS Optimization: The Complete Guide to Achieving Stable 20 TPS

Published on June 20, 2026

# Minecraft Server TPS Optimization: The Complete Guide to Achieving Stable 20 TPS

Nothing kills a Minecraft community faster than a laggy server. Blocks that won't break, mobs rubber-banding, Redstone misfiring — these are all symptoms of a server suffering from low TPS. In this guide, you'll learn exactly how to diagnose TPS drops and fix them permanently using real configuration values.

What Are TPS and Why Do They Matter?

TPS stands for Ticks Per Second. Minecraft processes all game logic in discrete units called ticks — 20 per second under ideal conditions. Here's what different TPS values mean in practice:

20 TPS = perfect performance, each tick takes exactly 50ms
15 TPS = noticeable lag, each tick takes ~67ms
10 TPS = severe lag, the game runs at half speed

When your server drops below 20 TPS, everything slows down proportionally: mob movement, Redstone timing, crop growth, and player interactions all suffer. The good news: low TPS always has a cause you can find and fix.

Step 1: Measure and Diagnose TPS

Never optimize blindly. First, find the actual source of the problem.

Basic TPS Monitoring

On Paper or Spigot servers, use /tps to see average TPS over the last 1, 5, and 15 minutes.

For deep analysis, install the Spark profiler plugin:

/spark profiler start

/spark profiler stop

Spark generates an interactive flame graph showing which methods consume the most CPU time. This immediately reveals whether lag comes from a plugin, entity processing, or chunk loading.

PulseNode automatically monitors your TPS in real time and alerts you to drops before players start complaining — giving you a persistent view of performance trends over time.

Step 2: Optimize spigot.yml

The spigot.yml file controls entity tracking and activation ranges — two of the biggest performance factors on busy servers.

Reduce Entity Tracking Ranges

world-settings: default: entity-tracking-range: players: 48 animals: 32 monsters: 40 misc: 16 other: 64 entity-activation-range: animals: 16 monsters: 24 raiders: 48 misc: 8 water: 8 villagers: 16

flying-monsters: 32

These values control how far away entities are actively simulated. Lower values mean fewer entities running AI calculations every tick — a direct TPS improvement.

Nerf Spawner Mobs

world-settings: default: mob-spawn-range: 6

nerf-spawner-mobs: true

Setting nerf-spawner-mobs: true disables AI for mobs spawned from mob spawners when no player is nearby. This is a massive win for servers with mob farms, as those farms often contain hundreds or thousands of entities.

Step 3: Configure paper-world.yml

Paper provides far more optimization options than vanilla Spigot. These settings live in config/paper-world-defaults.yml (Paper 1.19+) or paper-world.yml on older versions.

Optimize Chunk Behavior

chunks: auto-save-interval: 6000 delay-chunk-unloads-by: 10s entity-per-chunk-save-limit: experience_orb: 16 snowball: 8 ender_pearl: 8

arrow: 16

Limiting entities saved per chunk prevents situations where a single chunk contains thousands of XP orbs or projectiles that tank performance.

Fix Redstone Performance

Redstone is one of the most common TPS killers. Paper offers a dramatic improvement:

redstone: implementation: ALTERNATE_CURRENT

limit-looping-alt-current: true

ALTERNATE_CURRENT is an alternative Redstone implementation that handles updates far more efficiently than vanilla. Complex Redstone contraptions that cause heavy lag on vanilla Spigot often run smoothly with this setting.

Enable Entity Merging

entities: merge-radius: exp: 3.0

item: 2.5

XP orbs and dropped items within these radius values get merged into single entities, dramatically reducing entity count in areas like mob farms or mining sites.

Optimize Hoppers

Hoppers are notorious performance hogs because they check for items every single tick:

hopper: cooldown-when-full: true

disable-move-event: true

cooldown-when-full: true adds a delay before a full hopper tries to pull items again. disable-move-event: false prevents plugins from interfering with every hopper transfer — only set true if you don't use plugins that depend on hopper events.

Step 4: Tune bukkit.yml

spawn-limits: monsters: 50 animals: 10 water-animals: 3 water-ambient: 10 ambient: 1 chunk-gc: period-in-ticks: 400 ticks-per: animal-spawns: 400 monster-spawns: 5 water-spawns: 400

ambient-spawns: 400

Vanilla spawn limits are tuned for singleplayer. On a multiplayer server with 20+ players, the default values lead to massive entity counts. Reducing monsters to 50 and animals to 10 per world is a safe starting point — players will still encounter plenty of mobs.

The ticks-per values control how often the server attempts to spawn each mob type. Increasing animal-spawns to 400 means animals only attempt to spawn every 400 ticks (20 seconds) instead of every tick, which is completely fine since animal populations don't need to update constantly.

Step 5: server.properties Settings

view-distance=6
simulation-distance=4
network-compression-threshold=256

view-distance: Chunks rendered around each player. Values of 6–8 are a good balance between performance and visual quality.
simulation-distance: How far game mechanics are simulated. Can be lower than view-distance — players will see more chunks than are actively simulated.
network-compression-threshold: Packets larger than this value (in bytes) are compressed before sending. 256 is a solid default.

Step 6: Java Startup Flags

Optimized configs won't help much if Java's garbage collector is pausing your server every few seconds. Use Aikar's optimized JVM flags:

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 configure the G1 garbage collector specifically for Minecraft's memory patterns. The key benefit: GC pauses are shortened significantly, eliminating the characteristic "freeze then resume" lag that plagues poorly configured servers.

Important: Set both -Xms and -Xmx to the same value to prevent the JVM from constantly resizing the heap.

Step 7: Identify the Most Common TPS Killers

Even with perfect configs, some player behaviors will tank performance:

Mob farms without kill limits — A farm producing 500 entities with no mechanism to kill extras will eventually crash your server. Enforce per-chunk entity limits in paper-world.yml.

TNT cannons — Each TNT entity is simulated individually. Set max-tnt-per-tick: 100 in Paper's config to cap damage.

Laggy plugins — Use Spark to identify plugins consuming excessive CPU. Even popular plugins can have performance regressions in newer versions.

Terrain generation — If players are constantly exploring new territory, chunk generation will hammer your CPU. Consider pre-generating your world with a plugin like Chunky.

Conclusion: Performance Is an Ongoing Process

TPS problems are rarely a one-time fix. A new plugin version, a player building a larger Redstone machine, or simply more players joining can all introduce new lag sources over time.

[PulseNode](https://pulsenode.tech) gives you continuous visibility into your server's TPS trends, player counts, and performance metrics — so you can catch degradation early and investigate before your players notice. Combined with the configuration changes in this guide, you'll have both the foundation and the ongoing visibility needed to keep your server running smoothly.

Start today: install Spark, apply these config changes, and set up monitoring. Your players deserve a server that runs at a solid 20 TPS.