Minecraft Java Server Optimization 2026

A Minecraft Java server that lags is almost never a hardware problem — it's a configuration problem. This guide walks through every lever that matters: Paper over vanilla, Aikar's G1GC flags line by line, view/simulation distance math, paper.yml activation ranges, the spark profiler workflow, and pregeneration with Chunky. By the end your server will hold 20 TPS with meaningful headroom, or you'll know exactly which plugin / mod is eating the tick.

01 // Understanding TPS and MSPT

Before tuning anything, you have to measure. Two numbers matter:

Run /tps on a Paper/Purpur server at any time to see the last 1 min / 5 min / 15 min averages and current MSPT. The three colours mean:

• Green (20.0) — server is finishing every tick with spare time
• Yellow (~18–20) — server is struggling intermittently, players may feel micro-stutters
• Red (<18) — measurable lag: mobs stutter, doors open slowly, hits miss

02 // Which Server Fork: Paper vs Purpur vs Pufferfish vs Folia

Vanilla Minecraft is the single worst Java server software you can run at scale. Every optimization guide, including this one, assumes you've replaced it with a fork. The four that matter in 2026:

03 // Install Paper

Paper is the baseline this guide is written for. Grab the latest stable build directly from PaperMC. They publish an API that always returns the newest build number, so the script below never goes stale:

# Create a dedicated user if you haven't already
sudo adduser --disabled-password --gecos "" minecraft
sudo -iu minecraft

mkdir -p ~/paper-server && cd ~/paper-server

# Set your target Minecraft version
MC_VERSION="1.21.4"

# Query Paper API for the latest build number
BUILD=$(curl -s "https://api.papermc.io/v2/projects/paper/versions/${MC_VERSION}/builds" \
  | grep -oP '(?<="build":)[0-9]+' | tail -1)

# Download the JAR
wget "https://api.papermc.io/v2/projects/paper/versions/${MC_VERSION}/builds/${BUILD}/downloads/paper-${MC_VERSION}-${BUILD}.jar" \
  -O paper.jar

# Accept the EULA (you must have read and agree to https://aka.ms/MinecraftEULA)
echo "eula=true" > eula.txt

04 // Aikar's Flags — Tuned G1GC

Aikar's flags are a set of JVM garbage-collection arguments tuned specifically for Minecraft's allocation pattern. They became the standard because Minecraft creates a lot of short-lived objects (packet buffers, chunk sections, entity update events) that overwhelm the default G1GC settings and cause multi-second GC pauses.

Paste this into start.sh inside the server directory. Change the two RAM values to match your allocation (see the next section for the calculator):

#!/bin/bash
# Aikar's flags for Paper / Purpur / Pufferfish, 2026 update
# https://docs.papermc.io/paper/aikars-flags

java -Xms8G -Xmx8G \
  -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 paper.jar --nogui

What each flag actually does, in plain English:

chmod +x start.sh
./start.sh   # first-time launch generates world and configs

05 // Interactive RAM Allocator

Over-allocating RAM actually hurts Minecraft — bigger heaps mean longer GC pauses. Under-allocating causes OOM crashes. Use the calculator below to pick the right -Xms/-Xmx value for your setup:

06 // Tune server.properties

These are the highest-impact knobs in server.properties. Every setting below directly affects CPU load per tick:

07 // Tune paper-global.yml and paper-world-defaults.yml

On Paper 1.19+, the old single paper.yml was split into config/paper-global.yml and config/paper-world-defaults.yml. These are where the real entity and chunk optimizations live:

In config/paper-world-defaults.yml:

entities:
  spawning:
    per-player-mob-spawns: true      # CRITICAL: each player has their own mob cap
    despawn-ranges:
      monster:
        soft: 28                       # start despawning beyond 28 blocks (default 32)
        hard: 96                       # force despawn beyond 96 blocks (default 128)
  behavior:
    experience-merge-radius: 4.0       # merge nearby XP orbs
    nerf-spawner-mobs: true            # mobs from spawners have no AI (still drop loot)
  entity-activation-range:
    animals: 24                        # default 32
    monsters: 24                       # default 32
    raiders: 48                        # keep raids functional
    villagers: 24                      # default 32
    misc: 12                           # default 16
    water: 12                          # default 16
    tick-inactive-villagers: false     # massive win on villager-heavy servers

chunks:
  max-auto-save-chunks-per-tick: 6     # default 24 — lower values smooth out save spikes
  prevent-moving-into-unloaded-chunks: true

collisions:
  max-entity-collisions: 2             # default 8 — fewer collision checks on mob farms

08 // Profile with spark — find the real bottleneck

If your server lags after the tuning above, stop guessing. Install spark — it's free, maintained, and the single best performance tool for Minecraft:

# Drop the spark JAR into your plugins/ folder, restart the server, then in-game:
/spark profiler start
# ... let it run while you reproduce the lag (5–10 minutes is plenty)
/spark profiler stop

spark uploads a flame graph to the web and gives you a short URL. You'll instantly see:

• Which plugin is consuming the most CPU per tick (sorted %)
• Which chunks have the most entities/tile-entities (via /spark tickmonitor)
• Which entity types dominate (common culprits: item frames on large maps, armor stands in lobbies, minecart loops)
• Heap summary via /spark heapsummary — shows which classes are eating RAM

Most "laggy server" problems turn out to be one specific plugin or one specific farm. spark finds it in 10 minutes instead of you randomly disabling things for a week.

09 // Aikar's flags — explained, not copy-pasted

You'll see "Aikar's flags" mentioned on every Minecraft forum. They're the community-standard tuned G1GC arguments from Aikar (Empire Minecraft). Most guides just dump the copy-paste — here's what each flag actually does so you can adjust intelligently:

java -Xms8G -Xmx8G \
  -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 paper.jar nogui

10 // Audit your plugins — the #1 source of lag

In most lag investigations we do, a single poorly-written plugin accounts for 40–70% of tick time. Run this after installing spark:

# In-game or console:
/spark profiler start --timeout 300    # auto-stops after 5 minutes
# ... play normally, reproduce the lag ...
/spark profiler stop

Look at the flame graph sorted by self-time. If any single plugin is > 15% of tick time, investigate. Common offenders in 2026:

• Old anti-cheat plugins — many check too often per tick. Consider Vulcan, Matrix, or Grim as modern alternatives.
• EssentialsX with broadcast plugins — chat formatting loops can hit every tick if misconfigured.
• Worldguard + large region counts — every player movement checks every region. Keep region counts under 500 per world.
• Dynmap/BlueMap on tiny VPS — tile rendering can eat a whole core. Set render-triggers to manual, render off-hours.
• Custom skull / head plugins — many make blocking HTTP calls to Mojang on every interaction. Cache aggressively or replace.

11 // Pre-generate your world — biggest single-win optimization

Chunk generation is the most expensive thing a Minecraft server does, and it happens on the main thread. Every time a player walks into unexplored terrain, everyone on the server feels it. Solution: generate the world before players arrive.

Install Chunky (free, actively maintained, works on Paper/Purpur/Folia) and run:

# Generate a 5000-block radius around spawn (roughly 78 million blocks²)
/chunky radius 5000
/chunky start

# Check progress anytime:
/chunky status

# Pause if players are online and lag starts:
/chunky pause

On an NVMe VPS with 8 GB RAM, a 5000-block radius pre-generation finishes in 30–90 minutes. Once it's done, world-border your map to that radius (/worldborder set 10000) and you've eliminated chunk-gen lag forever. Players get smooth TPS, you get predictable disk usage.

12 // Modded Minecraft — different rules apply

Everything above was primarily about Paper/Purpur (plugin servers). Modded servers (Forge, NeoForge, Fabric) behave differently and need different tuning. Here's what actually changes:

Modded-specific pitfalls to check:

• Chunk loaders everywhere — ftb-chunks, chickenchunks, and similar let players keep chunks loaded 24/7. Every forced chunk is forever-tick. Cap per-player chunk loader limits in the config.
• AE2 / RefinedStorage auto-crafting — massive crafting patterns can spike tick time. Check tick reports for MEStorageBus or StorageChannel.
• Create-style rotating contraptions — a large windmill or 100-block piston contraption runs physics every tick. Limit max contraption size in Create config.
• Thousands of mob-farm entities — item frames, item entities, XP orbs. Tune the mod's own entity-limit configs, not just Paper's.
• Uncapped item pipe throughput — BuildCraft / Mekanism / Thermal pipes can push ticks to their knees. Rate-limit in each mod's config.

13 // Troubleshooting — common lag symptoms and fixes

Quick diagnostic table. Match the symptom, follow the fix.

14 // Hosting recommendations for optimized Minecraft

Software tuning has a ceiling. If your VPS has slow single-thread CPU or spinning-disk I/O, you will hit that ceiling fast. These are the plans we actually recommend after tuning hundreds of servers:

15 // Next steps

• Already setting up a new server? — Follow our server setup pattern and apply these optimizations from day one.
• Need a panel for easier management? — Pterodactyl or AMP both handle JVM flag management in a GUI.
• Running Bedrock instead? — See the Bedrock dedicated server guide — different engine, different tuning.
• Want a one-click managed option? — Windows hosting guide covers local hosting if you don't want a VPS at all.
• Check our tools — port reference, VPS sizing calculator, and more utilities for server owners.