Understanding Minecraft Server TPS: Why Ticks Drop and How to Fix Them

Minecraft server TPS counts how many game ticks your world completes every second, and 20 is the hard ceiling. Below that value the world runs in slow motion: mobs stutter, hoppers crawl, furnaces smelt late and redstone contraptions desync. Tick lag always has a measurable source (entities, chunk work, redstone, spawners), and a handful of commands is enough to expose it.

How a tick works and what 20 ticks per second really means

The game loop processes one tick every 50 milliseconds. Inside that window the engine moves entities, runs block updates, ticks block entities such as hoppers and furnaces, handles redstone propagation, processes chunk loading and saves, then sends packets to players. If all of that fits under 50 ms, the tick rate stays at 20.

When the work exceeds 50 ms, the tick simply takes longer. The engine does not skip anything: it falls behind. That value is called MSPT (milliseconds per tick), and it is a far better indicator than TPS because it shows headroom before any visible drop appears.

• MSPT under 30 ms: healthy, room for more players or more farms.
• MSPT between 30 and 45 ms: no visible lag yet, but any spike will break 20 TPS.
• MSPT above 50 ms: TPS is already dropping, players feel delayed block breaking.
• TPS under 15: mob AI, hoppers and daylight cycle visibly slow down.

The main tick loop is single-threaded in vanilla and in Paper, so raw single-core speed matters far more than core count. A CPU like the Ryzen 9 7950X3D, paired with DDR5 ECC memory and NVMe storage for chunk I/O, is what keeps Minecraft server hosting at Nexus Games responsive when a world grows heavy.

Reading Minecraft server TPS and MSPT in real time

Start with the built-in readouts before touching any configuration file. On Paper, Spigot and their forks, two commands give an immediate picture from the console or in game with operator rights.

/tps
/mspt
/forge tps

The /tps output shows three averages (1 minute, 5 minutes, 15 minutes). A green 20.0 across all three with a rising MSPT means you are close to the limit. A 20.0 on 15 minutes but 14.2 on 1 minute points to a recent event: a player reaching an unexplored area, a farm switching on, a backup running synchronously.

Reading	Likely meaning	Next step
TPS 20, MSPT 45+	No margin left	Reduce entity and chunk load
TPS drops only when players explore	Terrain generation	Pre-generate the world, set a border
Periodic 1 second freezes	Auto-save or GC pause	Tune save spread and JVM memory
Constant 12 to 16 TPS	Permanent entity or redstone load	Profile and locate the chunk

On vanilla builds without plugins, the engine ships its own profiler and tick controls. /debug start then /debug stop writes a report into the debug/ folder of the world directory, and recent versions expose direct tick commands.

/debug start
/debug stop
/tick query
/tick rate 20

The four usual culprits behind tick lag

Entity density

Entities are the most common cause. Each mob runs pathfinding, collision checks and AI goals every tick when a player is nearby. Item stacks on the ground, armour stands, minecarts, boats and especially villagers with their gossip and workstation logic add up quickly. A few thousand entities spread over a handful of chunks will flatten any world.

Chunk loading and terrain generation

Generating a brand new chunk is one of the heaviest operations in the game. A player flying an elytra at full speed across unexplored terrain forces continuous generation, structure placement and lighting work on the main thread. The same applies to Nether travel, where an 8:1 ratio means a short trip covers a lot of Overworld ground.

Redstone loops

Redstone updates cascade. A single observer clock left running, a hopper clock, or a comparator loop feeding itself produces thousands of block updates per second, all inside the tick. Contraptions built as a stress test and then forgotten behind a wall are a classic finding during profiling sessions.

Mob farms and spawners

Farms concentrate everything at once: mobs spawning, mobs dying, items dropping, hoppers scanning inventories. A large iron farm or a raid farm can hold the tick hostage on its own. Hopper chains are particularly expensive because each hopper checks the container above it and the container in front of it on a fixed schedule.

Profiling a spike and locating the guilty chunk

Guessing wastes time. The spark profiler, available as a plugin or mod for Paper, Fabric, Forge and NeoForge, samples the main thread and returns a call tree that names the exact class doing the work.

/spark profiler start --timeout 60
/spark profiler stop
/spark tickmonitor --threshold 100
/spark health --memory

Read the resulting report from the top: if ServerLevel.tickBlockEntities dominates, look at hoppers and furnaces. If EntityTickList or ServerLevel.tickNonPassenger leads, you have an entity problem. Heavy ChunkMap or ChunkGenerator entries point at exploration and view distance. Configuration details for each Paper option are documented in the official Paper configuration reference.

To count entities per chunk without a profiler, the vanilla data command still helps, and plugins such as LagAssist or Chunky expose per-chunk listings directly in chat.

/spark heapsummary
/minecraft:forceload query
/chunky trim

Settings that bring ticks back to 20

server.properties

Two values dominate everything else. view-distance controls how far chunks are sent to clients, simulation-distance controls how far the engine actually ticks mobs and blocks. Lowering simulation distance to 5 or 6 removes a large amount of work while players barely notice it.

view-distance=8
simulation-distance=5
max-tick-time=60000
sync-chunk-writes=false
network-compression-threshold=256

spigot.yml and bukkit.yml

Entity activation ranges decide at what distance a mob goes fully active. Shrinking them is the single most effective entity fix on a busy world.

entity-activation-range:
  animals: 16
  monsters: 24
  raiders: 48
  misc: 8
merge-radius:
  item: 3.5
  exp: 4.0
nerf-spawner-mobs: true
tick-inactive-villagers: false

spawn-limits:
  monsters: 40
  animals: 8
  water-animals: 3
  ambient: 1
ticks-per:
  monster-spawns: 4
chunk-gc:
  period-in-ticks: 400

paper-world-defaults.yml

Paper adds targeted switches that cut redundant work without changing gameplay for players. Disabling the hopper move event alone removes a constant plugin call on every item transfer.

hopper:
  disable-move-event: true
  cooldown-when-full: true
entity-per-chunk-save-limit:
  experience_orb: 50
  arrow: 16
misc:
  redstone-implementation: ALTERNATE_CURRENT
chunks:
  max-auto-save-chunks-per-tick: 6

Java memory and garbage collection

Long pauses that freeze the world for a second are usually garbage collection, not game logic. Set the minimum and maximum heap to the same value, keep G1GC tuned with the Aikar flag set, and resist the urge to allocate every gigabyte available: an oversized heap produces longer pauses.

java -Xms6G -Xmx6G -XX:+UseG1GC -XX:+ParallelRefProcEnabled \
  -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions \
  -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 \
  -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 \
  -jar paper.jar nogui

A vanilla world with a small group usually runs comfortably on 4 GB. A modpack with generated structures and hundreds of block entities often needs 8 GB or more, and heavy modded packs go beyond that. Allocate according to the pack, then verify with /spark health --memory.

World maintenance and long-term stability

Pre-generating the map removes terrain generation from live play. Running Chunky over a defined radius, then setting a world border at that same radius, turns exploration lag into a one-time task done while nobody is connected.

/chunky world world
/chunky radius 5000
/chunky start
/worldborder set 10000

Old abandoned chunks keep inflating the region files and slow down saves and backups. Trimming unvisited chunks and keeping automatic snapshots scheduled during low activity hours keeps disk work away from peak time. Restart schedules also help modded worlds where memory fragments over long uptimes.

Audit plugins the same way you audit farms. A scheduler running every tick, an economy plugin querying a database synchronously, or an outdated build compiled against an old API can hold the tick hostage. Disable half, measure, repeat: binary search finds the offender faster than reading configuration files. Other administration walkthroughs are collected on the Nexus Games blog, and the same profiling logic applies across All our game servers.

Conclusion

Fix the measurement before the world. Install spark, read MSPT rather than TPS, and only then touch a configuration file. In practice, lowering simulation-distance and tightening entity activation ranges solves the majority of cases in minutes. The error to avoid first is throwing more RAM at a problem that is single-thread bound: an oversized heap lengthens garbage collection pauses and makes the stutter worse, not better.

FAQ

Does adding more RAM increase TPS?

Rarely. Memory only helps when the Java heap is genuinely saturated and garbage collection runs constantly, which shows up as repeated one second freezes. Tick lag caused by entities, redstone or chunk generation is limited by single-thread CPU speed, and extra memory changes nothing there. Check /spark health --memory first: if used heap stays well under the maximum, the bottleneck is elsewhere.

How do I tell server tick lag from client FPS lag?

Press F3 in game and look at the graph. Low client FPS with smooth mob movement and instant block breaking means the problem is your graphics settings or render distance locally. Delayed block breaking, mobs teleporting back, items taking a second to drop and chests opening late point at the tick loop instead. Running /tps settles the question immediately.

Can I raise the tick rate above 20 to compensate for lag?

No. Recent versions expose /tick rate, but raising it above 20 speeds up the whole world (mob movement, crop growth, redstone timing) and multiplies the work per second, so an already loaded world degrades further. That command is meant for testing and debugging with /tick freeze and /tick step. Keep the value at 20 and remove the actual source of the load.