Comprendre et corriger les chutes de TPS sur un serveur Minecraft

Minecraft server TPS is the number that separates a world where combat feels instant from one where every hit registers half a second late. Ticks per second measures how many times the game loop actually completes each second, and once it drops below 20 the whole simulation slows down — mobs stutter, redstone misfires, chunks lag behind players. This guide explains what really controls that number and how to hunt down the spikes that kill it.

What Really Drives Minecraft Server TPS

Minecraft's tick loop is single-threaded by design. Redstone, entity AI, block updates and world saving all happen sequentially inside one thread, no matter how many CPU cores the machine has. That single fact explains most performance complaints better than any other metric.

Single-Core CPU Speed

Because the main tick runs on one thread, raw core count barely matters — clock speed and instructions-per-cycle do. A high-frequency Ryzen core clears the tick loop faster than a slower CPU split across many virtual cores, which is why the underlying processor choice affects TPS more than RAM allocation ever will. Giving the JVM more heap won't speed up a tick that's stuck waiting on a slow core; it just delays garbage collection pauses.

Chunk Loading

Every chunk a player approaches has to be read from disk, decompressed, lit and populated with entities before it's handed to the client. On mechanical or network storage, this I/O work competes with the world save thread and autosave cycles, producing short but sharp freezes. NVMe storage removes most of that wait, since read latency drops from milliseconds to microseconds — a small detail that becomes very visible when ten players load new terrain at once.

View and Simulation Distance

View distance controls how many chunks get rendered and sent to clients; simulation distance controls how many chunks are actually ticked — mobs moving, crops growing, redstone updating. Simulation distance is the expensive one. Doubling it roughly quadruples the number of ticked chunks around every player, which directly loads the single tick thread discussed above.

Entity Count

Mob farms, item duping loops, villager breeders and floating item stacks all add entities that need AI pathing, collision checks and tick updates every single cycle. A world that looks empty on the surface can still choke the tick loop if a cave system below is packed with cave spiders or a dropped-item pile has grown unnoticed.

If you're setting up a fresh world and want the hardware side handled correctly from day one — high-frequency CPU, NVMe storage, anti-DDoS included — check our Minecraft server hosting page for the technical specs behind each offer.

Reading a Timings Report to Diagnose Lag Spikes

Guessing which plugin or mob farm causes a lag spike wastes hours. A timings report or a spark profile gives you the actual breakdown of where each tick's time goes, down to the plugin and even the specific listener.

Installing and Running Timings or Spark

Paper and Spigot builds ship with a built-in timings system; spark is the modern profiler most admins run instead, since it also works on Fabric and Forge. From the console or an SSH session into the machine running the process:

/timings on
# let it run for 5-10 minutes during normal or laggy play
/timings paste

# or with spark (recommended, more detail):
/spark profiler start
/spark profiler stop
/spark profiler paste

Both commands return a URL with an interactive report. Open it and look at the tick loop breakdown before touching any config file.

Interpreting Tick Duration

The target is 50ms per tick, which equals 20 TPS. A report showing average tick times of 80-120ms points to a load problem, not a network problem — network lag shows up as player-side rubberbanding while the server-side TPS stays fine. Look at the percentage breakdown between "Minecraft" (vanilla mechanics), individual plugins, and entity/tile entity ticking.

Spotting the Real Bottleneck

Common patterns worth checking first:

• A single plugin consuming 30%+ of tick time — usually a poorly optimized economy, chat, or anti-cheat plugin running heavy checks every tick.
• Entity ticking dominating the report — almost always a mob farm, item pile, or villager breeder gone unchecked.
• World save / chunk I/O spikes lining up exactly with the autosave interval — a storage speed issue more than a code issue.
• Redstone/block updates spiking after a specific player action — often a large-scale farm or clock circuit left running.

Fixing the Most Common TPS Killers

Once the timings report points at a cause, the fix is usually a config change rather than a full rebuild of the world.

Trimming View and Simulation Distance

On Paper-based builds, simulation distance can be tuned independently from view distance, which lets you keep visuals reasonable while cutting the number of actively ticked chunks:

# server.properties
view-distance=8
simulation-distance=6

Dropping simulation distance from 10 to 6 on a populated survival world often recovers several TPS instantly, since it directly reduces the chunk count feeding the single tick thread.

Controlling Entity and Redstone Overload

Paper's paper-world-defaults.yml exposes per-category entity caps and merge radius settings that cut down duplicate AI processing without deleting anything visible to players:

entities:
  spawning:
    per-player-mob-spawns: true
  entity-activation-range:
    monsters: 24
    animals: 16
    misc: 8

Lowering activation ranges means distant mobs stop running full AI ticks and drop into a cheaper idle state. Combine this with a periodic /kill @e[type=item] command or a plugin-based item cleanup timer to stop dropped-item piles from accumulating after large builds or mob grinding sessions.

Chunk Pre-generation and Loaded Chunk Limits

Pre-generating the world border ahead of time with a tool like Chunky avoids the worst spikes — the ones that happen the first time a player walks into unexplored terrain, since generation is far more expensive than simply loading an already-saved chunk from NVMe storage:

/chunky world world
/chunky radius 5000
/chunky start

Run this during low-traffic hours so the one-time generation cost doesn't collide with peak player activity.

Keeping Minecraft Server TPS Stable Over Time

TPS problems creep back in gradually as builds grow, plugins get added, and mob farms multiply. A short maintenance routine catches regressions before players start complaining in chat.

• Run a spark profile monthly, or right after adding any new plugin, to catch regressions early.
• Schedule a clean restart during low-population hours to clear accumulated entities and reset the JVM heap:

systemctl restart minecraft-paper

Keep automatic backups active before every plugin update or config change, so a bad tweak can be rolled back in minutes instead of hours.

Watch the console for repeated "Can't keep up!" warnings — they report exactly how many milliseconds behind the tick loop fell, which is a faster early-warning signal than waiting for player reports.

Managing all of this through a panel makes the loop faster: live console access to catch warnings in real time, one-click restarts, and file access to edit paper-world-defaults.yml without an FTP client. Our Pterodactyl VPS option and our own panel-based Minecraft environments both expose these controls directly. For a full list of what else runs well on the same kind of infrastructure, see All our game servers, and browse more admin write-ups on the Fly-Serv blog.

For deeper reference on Paper-specific flags and defaults, the official PaperMC configuration documentation covers every setting mentioned above in more detail.

Stable tick rate isn't about one magic setting — it's the combination of fast single-core processing, quick chunk I/O, sane view and simulation distances, and a entity count kept under control. Read a timings report before changing anything, fix the actual bottleneck it shows, and recheck after every major build or plugin addition.

FAQ

What TPS value counts as a real problem?

Anything sustained below 18-19 TPS is noticeable to players. Occasional drops to 15 during a big explosion are normal; a constant average under 17 means it's time to run a timings or spark report.

Does adding more RAM fix low TPS?

Rarely. TPS is a CPU and I/O problem tied to the single tick thread, not a memory problem. Over-allocating RAM can actually hurt performance by triggering longer garbage collection pauses. Fix the tick bottleneck first, then tune memory.

How often should I run a spark profile?

Right after adding a new plugin or mod, after any big build project (farms, redstone contraptions), and roughly once a month as routine maintenance to catch slow entity or item buildup before it becomes noticeable.