Understanding Minecraft TPS: What It Means & How to Improve Server Performance (2026)

If you've ever heard server admins talking about "TPS" or noticed warnings like "Can't keep up! Is the server overloaded?", you've encountered one of Minecraft's most critical performance metrics. Understanding TPS (Ticks Per Second) is essential for running a smooth, lag-free Minecraft server.

This guide explains what TPS is, why it matters, how to monitor it, and most importantly - how to fix low TPS issues affecting your server's performance.

What is TPS in Minecraft?

TPS (Ticks Per Second) measures how many game ticks your Minecraft server processes every second. A tick is Minecraft's fundamental unit of time - the game loop that updates everything in the world.

The Target: 20 TPS

Minecraft servers are designed to run at 20 TPS (one tick every 50 milliseconds). At this rate:

• Players experience smooth, responsive gameplay
• Redstone contraptions work correctly
• Mobs move and behave normally
• Crops grow at the expected rate
• Day/night cycles progress smoothly (20 minutes per day)

When TPS drops below 20, everything in the game slows down - including player movement, mob spawning, crop growth, and redstone circuits. This is commonly referred to as "server lag" (not to be confused with network latency).

TPS vs FPS vs Ping: Understanding the Difference

Players often confuse different types of lag. Here's how they differ:

Low TPS affects all players simultaneously, while FPS and ping issues are client-specific. If everyone on your server reports lag at the same time, TPS is likely the culprit.

Why TPS Drops Below 20

Several factors can cause TPS to drop:

1. Too Many Entities

Every mob, item, minecart, and armor stand must be processed each tick. Servers with thousands of entities struggle to maintain 20 TPS.

Common Culprits:

• Mob farms producing excessive entities
• Item drops from grinders not being collected
• Abandoned minecart systems
• Excessive armor stands in spawn areas

2. Redstone Lag

Complex redstone contraptions, especially observer-based clocks and hopper chains, consume significant CPU time per tick.

Heavy Redstone:

• Observer/piston clocks running constantly
• Massive hopper sorting systems
• Flying machines covering large areas
• Rapid piston mechanisms

3. Chunk Loading

Loading new chunks requires reading world data from disk and generating terrain if needed. Players exploring rapidly or using teleportation can cause TPS spikes.

4. Plugin/Mod Overhead

Poorly optimized plugins or mods that run code every tick can drag down TPS. Even well-written plugins add computational overhead.

5. Insufficient Server Resources

If your server lacks CPU power or RAM, it physically can't process 20 ticks per second during demanding operations.

6. World Generation

Generating new chunks in real-time is CPU-intensive. Servers without pre-generated worlds experience TPS drops during exploration.

How to Monitor TPS

In-Game Commands

Most server software provides TPS monitoring commands:

Spigot/Paper:

/tps

Output example:

TPS from last 1m, 5m, 15m: 19.8, 19.5, 19.2

Plain Bukkit (CraftBukkit) has no /tps command. Paper also adds /mspt, which shows how many milliseconds each tick takes (under 50ms is needed for 20 TPS).

Spark (Advanced Profiling Plugin):

Spark provides detailed performance analysis:

/spark tps
/spark profiler start
/spark profiler stop
/spark profiler open

Spark generates web-based reports showing exactly what's consuming tick time - invaluable for diagnosing issues.

Server Console

The server console warns you when TPS drops:

[Server thread/WARN]: Can't keep up! Is the server overloaded? Running 2034ms or 40 ticks behind

This message means the server is struggling to maintain 20 TPS. If you see this frequently, performance optimization is needed.

External Monitoring Tools

Grafana + Prometheus:

For professional server monitoring, integrate metrics with Grafana. Many hosting providers offer built-in dashboards showing TPS, RAM usage, and CPU load over time.

Minecraft Server Status Bots:

Discord bots like Minecraft Server Status ping your server to show whether it's online and how many players are connected. A ping doesn't report TPS, so TPS alerts need data exported from the server itself (for example, a metrics plugin feeding Prometheus).

How to Improve Low TPS

1. Entity Management

Clear Excess Entities:

Use plugins to automatically remove dropped items and limit mob spawning:

• ClearLagg: Removes items, limits entities, prevents lag machines
• EntityTrackerFixer: Optimizes entity tracking calculations
• FarmControl: Limits entities in specific areas

Configuration Example (ClearLagg):

# config.yml
auto-removal:
  enabled: true
  broadcast-message: true
  broadcast-removal: false
  autoremoval-interval: 460 # Remove every 460 seconds (~7.5 minutes)
  world-filter:
    - world
  boat: true
  falling-block: true
  experience-orb: true
  painting: false
  projectile: true
  item: true
  itemframe: false
  minecart: true
  primed-tnt: true
  arrow: true

Manual Entity Cleanup:

/minecraft:kill @e[type=item]
/minecraft:kill @e[type=arrow]

2. Redstone Optimization

Limit Hopper Usage:

Hoppers check for items every tick. Replace hopper chains with water streams or minecart systems where possible.

Paper's Anti-Hopper Lag:

Paper includes settings to reduce hopper lag. Edit config/paper-world-defaults.yml:

hopper:
  cooldown-when-full: true # Reduces hopper checks when full
  disable-move-event: false # true skips InventoryMoveItemEvent (breaks some plugins)
  ignore-occluding-blocks: false

Use Redstone Sparingly:

• Avoid always-on observer/piston clocks
• Don't use /gamerule randomTickSpeed 0 (random_tick_speed on 1.21.11+) to pause unused farms - the gamerule applies to the whole world and stops crop growth, leaf decay, and other random ticks everywhere
• Replace redstone lamps with less intensive light sources
• Optimize sorting systems with fewer hoppers

3. Pre-Generate Your World

Pre-generating chunks eliminates world generation lag during gameplay.

Using Chunky:

Chunky is the best pre-generation plugin:

/chunky world <world_name>
/chunky radius 5000          # Pre-generate 5000 blocks from spawn
/chunky start                # Begin pre-generation
/chunky pause                # Pause if TPS drops

When to Pre-Generate:

• Before opening your server to players
• After major world border expansions
• Before events involving lots of exploration

Pre-generating a 10,000-block radius can take hours but dramatically improves TPS during normal gameplay.

4. View Distance Optimization

Reducing view distance decreases the number of loaded chunks, improving TPS.

Edit server.properties:

# Default is 10, reduce to 6-8 for better TPS
view-distance=6
# Controls how far away chunks are ticked (vanilla 1.18+)
simulation-distance=6

Per-World View Distance (Spigot/Paper):

Spigot and Paper allow different view distances per world in spigot.yml:

# spigot.yml
world-settings:
  default:
    view-distance: default # Uses the server.properties value
  world_nether:
    view-distance: 6 # Lower for Nether
  world_the_end:
    view-distance: 10

Player Testing:

Players typically notice minimal difference between 8 and 10 view distance, but servers see significant TPS improvements.

5. Use Paper Over Spigot

Paper is an optimized fork of Spigot with hundreds of performance improvements:

• Faster entity tracking
• Improved chunk loading
• Optimized redstone
• Better mob pathfinding
• Configurable hopper optimizations

Entity Activation Range (spigot.yml, used by Spigot and Paper):

world-settings:
  default:
    # Reduce entity activation range
    entity-activation-range:
      animals: 32
      monsters: 32
      raiders: 48
      misc: 16
      water: 16
      villagers: 32
      flying-monsters: 32

Most Spigot plugins run on Paper without changes. Paper is now a hard fork of Spigot, though, so plugins that depend on Spigot internals may need updates - test your plugins before switching.

6. Optimize Plugin Usage

Audit Your Plugins:

Use /spark profiler to identify problematic plugins (Paper removed Timings in 1.21.3 and uses spark instead):

/spark profiler start
# Wait 5-10 minutes during typical server load
/spark profiler stop

This generates a web report showing which plugins consume the most tick time. Consider:

• Replacing inefficient plugins with optimized alternatives
• Disabling unused features in plugin configs
• Updating to latest plugin versions
• Removing plugins that aren't essential

Common Performance-Heavy Plugins:

• Mob stacking plugins (use entity limiters instead)
• Advanced anti-cheat systems (configure carefully)
• Dynmap or BlueMap (both render on the server, so run large renders during quiet hours)
• WorldEdit large operations (educate staff on limits)

7. Increase Server Resources

If optimization isn't enough, upgrade your hosting plan:

CPU Priority:

TPS is primarily CPU-bound. Single-thread performance matters more than core count. Look for hosting with:

• Modern CPUs (Ryzen 5000/7000 series, Intel 12th/13th gen)
• High clock speeds (3.5GHz+ base, 4.5GHz+ boost)
• Dedicated cores (not oversold shared hosting)

RAM Requirements:

More RAM prevents garbage collection pauses that hurt TPS:

• Vanilla (10 players): 2-3GB
• Plugins (20 players): 4-6GB
• Modded (Forge/Fabric, 10 players): 6-8GB
• Heavy modpacks: RLCraft 6-8GB minimum (8-10GB recommended), ATM9 10GB minimum (12GB recommended)

Estimate yours with the RAM Calculator.

8. Java Arguments Optimization

Use Aikar's flags for optimized garbage collection:

For 4-10GB Servers:

java -Xms4G -Xmx4G -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 -Dusing.aikars.flags=https://mcflags.emc.gs
-Daikars.new.flags=true -jar server.jar nogui

These flags reduce garbage collection pauses that cause TPS spikes. Many hosts apply these automatically.

Advanced Troubleshooting

Use Spark Profiler

Spark provides unparalleled insights into performance:

/spark profiler start
# Let it run for 1-2 minutes during laggy periods
/spark profiler stop
/spark profiler open

The web interface shows:

• Which entities consume most time
• Expensive block ticks (redstone, crops, water)
• Plugin CPU usage breakdown
• Method-level profiling of Java code

Identify Laggy Chunks

Spark Report Analysis:

Spark profiles show which entities, block entities, and plugins use the most tick time. Look for:

• Chunks with excessive entities
• Chunks with many hoppers
• Chunks with active redstone clocks

Then find the areas responsible in-game.

Manual Inspection:

Teleport to suspect locations and observe:

/tp @s <x> ~ <z>

Look for:

• Hundreds of mobs in small areas
• Complex redstone machines
• Item duplication glitches
• Chunk loading issues (corrupted chunks)

Server Profilers

Java Flight Recorder (JFR):

For advanced users, JFR provides deep JVM profiling:

java -XX:+FlightRecorder
-XX:StartFlightRecording=duration=60s,filename=recording.jfr -jar server.jar

Analyze with JDK Mission Control.

Common TPS Myths Debunked

Myth 1: "More RAM = Higher TPS"

Reality: RAM prevents out-of-memory crashes but doesn't directly improve TPS. TPS is CPU-bound. Excessive RAM can even hurt performance by increasing garbage collection time.

Myth 2: "TPS Below 20 is Always Bad"

Reality: Brief TPS dips during chunk generation or world saves are normal. Sustained TPS below 18 is problematic.

Myth 3: "Removing All Entities Fixes TPS"

Reality: While entities affect TPS, overly aggressive culling breaks farms, grinders, and gameplay mechanics. Balance is key.

Myth 4: "Client-Side Lag = Server TPS"

Reality: Players with low FPS often blame the server. Check TPS before diagnosing - if TPS is 20, the issue is client-side or network-related.

Best Practices for Maintaining 20 TPS

1. Monitor Regularly: Check TPS during peak hours, not just when empty
2. Set Entity Limits: Use plugins to cap mobs per chunk
3. Educate Players: Teach players not to build lag machines
4. Pre-Generate Worlds: Always pre-gen before opening to public
5. Optimize Spawn: Keep spawn areas light on entities/redstone
6. Regular Cleanup: Schedule weekly entity removal during restarts
7. Update Software: Keep Paper, plugins, and Java updated
8. Limit World Size: Use world borders to prevent infinite exploration
9. Backup Regularly: Performance issues can corrupt worlds
10. Test Before Launch: Stress-test your server with bots before real players

When to Upgrade Your Hosting

If you've exhausted optimization options but still face TPS issues, consider upgrading:

Signs You Need More Resources:

• TPS consistently below 18 during normal gameplay
• "Can't keep up" warnings every few minutes
• Plugins disabled/optimized but TPS still low
• View distance already at 6 or below
• Server struggles with 10-20 players

What to Look For:

• CPU Performance: Prioritize single-thread speed over core count
• Dedicated Resources: Avoid oversold "unlimited" hosting
• Fast SSD Storage: Faster disk I/O reduces chunk loading lag
• Low Latency: Choose data centers near your player base
• Scalability: Ability to upgrade RAM/CPU without migrating

ChunkPod is in early access. You can join the waitlist at chunkpod.com.

Conclusion

Understanding TPS is fundamental to running a successful Minecraft server. By monitoring TPS, identifying bottlenecks with tools like Spark, and applying targeted optimizations - from entity management to Paper configuration - you can maintain smooth, responsive gameplay for your community.

Remember: 20 TPS is the goal, not a bonus. If your server consistently runs below 19 TPS, performance optimization should be your top priority. Start with low-hanging fruit like entity cleanup and view distance, then move to advanced optimizations like Paper configuration and plugin audits.

With the right combination of software optimization and adequate server resources, achieving stable 20 TPS is entirely achievable - even on busy servers with dozens of players.

Further Reading

• How to Fix Minecraft Server Lag (Complete Guide)
• RAM Calculator
• Paper vs Spigot vs Fabric vs Forge - Which to Choose
• Paper Official Documentation
• Spark Profiler Documentation
• Aikar's Flags Explained