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:

Paper/Spigot/Bukkit:

/tps

Output example:

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

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 can track TPS and alert you when it drops below thresholds.

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 paper-global.yml:

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

Use Redstone Sparingly:

• Avoid always-on observer/piston clocks
• Use /gamerule randomTickSpeed 0 to disable crop growth in unused farms
• 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. Read our full guide: Pre-generating Chunks with Chunky.

4. View Distance Optimization

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

Edit server.properties:

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

Per-World View Distance (Paper):

Paper allows different view distances per world:

# paper-world-defaults.yml
view-distance:
  default: 8
  world_nether: 6 # Lower for Nether
  world_the_end: 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

Paper-Specific Optimizations (paper-global.yml):

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

# Optimize chunk loading
chunk-loading:
  autoconfig-send-distance: true
  enable-frustum-priority: true
  min-load-radius: 2
  max-concurrent-sends: 2
  target-player-chunk-send-rate: 100.0

# Async pathfinding (huge performance gain)
async-pathfinding:
  enabled: true
  max-threads: 4

Switch from Spigot to Paper with zero plugin compatibility issues - Paper is a drop-in replacement.

6. Optimize Plugin Usage

Audit Your Plugins:

Use /timings (Spigot/Paper) or /spark profiler to identify problematic plugins:

/timings on
# Wait 5-10 minutes during typical server load
/timings paste

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 (use BlueMap instead, renders offline)
• 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 (ATM9, RLCraft): 10-16GB

Read our guide: How Much RAM Does a Minecraft Server Need?

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

Timings Report Analysis:

Timings reports show chunks with high tick time. Look for:

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

Investigate those chunk coordinates in-game to find the source.

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:+UnlockCommercialFeatures -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
• NVMe 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

For managed hosting, check out ChunkPod.

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)
• How Much RAM Does a Minecraft Server Need?
• Paper vs Spigot vs Fabric vs Forge - Which to Choose
• Paper Official Documentation
• Spark Profiler Documentation
• Aikar's Flags Explained