How to Optimize Your Minecraft Server for Constant 20 TPS: Complete Performance Guide

#Introduction to Minecraft Server Optimization

Maintaining 20 TPS (Ticks Per Second) is the top benchmark for any successful multiplayer Minecraft community. When TPS drops below 18, players begin to notice block breaking delays, delayed mob AI, projectile stuttering, and general input latency.

On CoalByte Cloud, every game server runs on high-frequency enterprise processor cores and ultrafast NVMe storage. However, tuning your server configurations remains essential to ensure that entity counts, redstone farms, and high player numbers never cause server lag.

1. Choose the Optimal Server Software

The default Vanilla jar distributed by Mojang lacks multi-threading optimizations, asynchronous chunk processing, and anti-lag safeguards. We strongly recommend choosing one of the following modern engines:

• Purpur: Built on top of Paper and Pufferfish, Purpur offers the highest performance headroom and allows granular control over entity tick rates, mob mechanics, and gameplay parameters.
• Paper: The trusted industry standard for Spigot and Bukkit compatibility, stability, and fast security fixes.
• Fabric + Lithium: Ideal for technical vanilla survival communities that require strict 100% parity with vanilla redstone mechanics and mob spawning.

2. Fine-Tuning paper-world-defaults.yml and purpur.yml

In your CoalByte File Manager, navigate to config/paper-world-defaults.yml and configure these performance-proven settings:

# Simulation distance handles game mechanics (mob AI, crops, redstone)
simulation-distance: 4

# View distance handles player render distance (sent from server)
view-distance: 6

# Entity activation ranges: stop ticking mobs that are far from players
entity-activation-range:
  animals: 16
  monsters: 24
  raiders: 32
  misc: 8
  water: 12
  tick-inactive-villagers: false
  ignore-spectators: true

# Despawn distances to prevent runaway entity clutter
entities:
  spawning:
    despawn-ranges:
      monster:
        soft: 28
        hard: 64

In purpur.yml, disable expensive pathfinding checks on idle mobs:

mobs:
  villager:
    lobotomize:
      enabled: true
      check-interval: 100

3. Server Properties Optimization

Open server.properties in your root directory and verify these parameters:

• view-distance=6
• simulation-distance=4
• network-compression-threshold=256
• max-tick-time=60000 (prevents watchdog crash timeouts during temporary heavy world gen)
• sync-chunk-writes=false (allows asynchronous chunk writing without blocking the main server tick loop)

4. Pre-Generate Your World Chunks with Chunky

Over 80% of server lag spikes occur when players explore into newly generated terrain. You can eliminate this entirely by pre-generating your world beforehand:

1. Download the free Chunky plugin into your /plugins directory.
2. Restart your server and execute these commands in your CoalByte Live Console:

/chunky world world
/chunky shape circle
/chunky radius 4000
/chunky start

Let the task complete while no players are online. Once finished, terrain loading becomes pure disk reads rather than intensive CPU calculations.

5. Aikar's Garbage Collection (G1GC) Flags

Java memory allocation can suffer from "Stop-the-World" pauses if standard garbage collector flags are used. On CoalByte, our containers automatically support Aikar's Flags:

-XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -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

6. Diagnose Remaining Bottlenecks with Spark

If players ever report TPS drops, run the Spark profiler directly from your console:

/spark sampler --timeout 60

The generated web report will display exact breakdown percentages identifying whether redstone clocks, entity tick overloads, or specific plugin listeners are consuming CPU cycles.