LagXpert Free Java/Bedrock

⚡ LagXpert Free v2.7 — Stop Guessing Why Your Server Lags

Most lag plugins tell you your TPS. LagXpert tells you which chunk is causing it, why, and fixes it for you.

Free. No premium tier. No dependencies. Java and Bedrock. Real Folia support.

The Feature Nobody Else Has: Actual Lag Diagnosis

You know the drill. TPS drops to 14. You check

/tps

. It says 14. Now what?

You start guessing. Maybe it's a mob farm. Maybe someone built a hopper monstrosity. Maybe it's a redstone clock. You fly around the map hoping to spot something, or you restart and hope.

/lagxpert diagnose

ends that. It scans every loaded chunk, ranks them by how much pressure each one is actually creating, and tells you in plain English what's wrong:

Load is concentrated: the top 5 chunks account for 78% of all detected pressure. Fixing a handful of locations will likely resolve most of it, starting with world at -1240, 512 (94 hoppers).

The most common violation is 'hoppers', over its limit in 7 of the top chunks. Lowering that limit, or dealing with the builds responsible, will have the widest effect.

TPS is 15.2 but no chunk exceeded its limits. The cause is likely outside LagXpert's scope: another plugin, world generation, disk I/O, or an undersized host.

That last one matters. LagXpert will tell you when the problem isn't something it can fix, so you stop looking in the wrong place.

Why the ranking is actually useful

Other tools rank by raw entity count. That surfaces the wrong chunks. A chunk with 40 mobs where the limit is 200 is perfectly fine. A chunk with 12 hoppers where the limit is 8 is your problem.

LagXpert scores every chunk as a percentage of the limit that actually applies to it — including per-world limits and any live adaptive tightening. It also weighs how often it has already had to clean that chunk up, because a location the plugin fights with twenty times an hour matters more than one that happens to be full right now.

Diagnosing lag doesn't cause lag

Chunk snapshots are taken on the owning thread; all scoring happens asynchronously. Results are cached briefly so a command and a GUI opened together share one scan, and overlapping scans are rejected rather than queued.

️ Interactive Diagnostics GUI — Built for Bedrock From Day One

Five screens, navigable in-game:

Real Bedrock support, not an afterthought

Bedrock players reach your server through Geyser, which translates Java inventory packets — and that translation is not lossless. LagXpert handles it properly:

• 
  Every slot position is computed from the actual screen size, so nothing is ever placed where a Bedrock client can't render it
  []Materials Geyser renders badly (spawn eggs, command blocks, structure blocks) are substituted automatically
  Tooltips capped before Bedrock starts truncating them unpredictably
  If the inventory can't be opened at all, the full report is delivered as chat text — a Bedrock admin is never left without a diagnosis

The same compatibility layer is applied to the configuration GUI too, so both interfaces behave identically for Java and Bedrock players.

Autonomous Emergency Response

A four-level state machine that watches TPS and memory and acts on its own:

Hysteresis prevents flapping: three consecutive bad readings to escalate, five good to de-escalate, minimum time in each state. It also escalates on sustained degradation — a server pinned at 12 TPS for two minutes is an emergency in practice, even if it never crosses the raw threshold.

Every state and every response is configurable.

/lagxpert emergency force-normal

is your panic button.

Natural spawn blocking is precise. It suppresses environmental spawning pressure only — spawn eggs, breeding, plugin spawns and commands keep working, because blocking those makes a server look broken rather than busy. The exact set is yours to configure, and players with bypass permission are always exempt.

Limits That Adapt to Your Server

Every per-chunk limit scales with real-time server health. When TPS drops or memory climbs, limits tighten. When the server recovers, they return to your configured values.

Two inputs are combined — continuous health (TPS + memory) and the discrete emergency state — and whichever is more restrictive wins. They're never multiplied, which would compound into unplayable values.

• 
  []Limits are only ever scaled down. Your configured number is always the ceiling.
  []A configurable floor guarantees limits can never collapse to something unplayable.
  []Per-category sensitivity: let mobs react hard while leaving storage nearly fixed so you don't disrupt player builds.
  []Per-player limits granted through permissions are honored verbatim and never scaled.

One-Command Optimization Profiles

Four presets you can switch between instantly:

/lagxpert profile relaxed small servers, minimal restrictions
/lagxpert profile balanced the sensible default
/lagxpert profile aggressive large servers or weak hardware
/lagxpert profile performance events and crisis mode
/lagxpert profile revert undo, exactly

revert

restores your configuration, not an assumed default — the values a profile replaces are snapshotted before anything is written. Apply a second profile on top of a first and revert still takes you all the way back to where you started.

There's an auto-revert timer too, because everyone has applied an aggressive profile during an incident and then forgotten about it.

Real Folia Support

Folia splits your server into independently ticking regions. An entity may only be touched by the thread that owns its chunk, which means no thread is allowed to sweep an entire world. Plugins that call

world.getEntities()

and remove things are simply not Folia-safe, whatever their description claims.

LagXpert dispatches every entity operation per chunk through the region scheduler: item cleaning, entity cleanup, vehicle cleanup, per-chunk entity trimming, the emergency AI freeze, the diagnostics scan, even entity counting for snapshots.

Bonus for Spigot and Paper users: the same dispatch processes chunks in batches spread across ticks, turning one long stalling tick into several short ones. That matters, because these sweeps run precisely when your server is already struggling.

Per-World Configuration

Different rules for the Nether, the End, creative hubs, or any custom world. Drop a file named after the world into

config/worlds/

and override only what you need — everything else inherits the global value.

Overridable per world: all 13 per-chunk block and mob limits, the total entity ceiling, chunk unload timing, chunk preloading, and TPS alert thresholds.

Full Audit Trail

Every corrective action LagXpert takes is recorded with type, world, chunk, count, trigger and timestamp — mob removals, entity cleanups, item clears, chunk unloads, blocked spawns, blocked placements, redstone cuts, explosion limits, vehicle removals, AI toggles, state transitions, config changes.

Queryable in-game through

/lagxpert status

and the diagnostics GUI. When a player asks "what happened to my minecart", you have an answer.

⚙️ Everything Else

Limits & enforcement

• 
  []Per-chunk limits for mobs, hoppers, chests, furnaces, blast furnaces, smokers, barrels, droppers, dispensers, shulker boxes (all 16 colours), TNT, pistons and observers
  []Redstone circuit tracking with a flood-fill circuit breaker that finds every connected component instead of snipping one wire and hoping
• Granular bypass permissions, plus per-player custom limits via permission nodes

Cleanup

• 
  []Item cleaner with configurable warnings and per-world exclusion lists
  Abyss recovery — players can retrieve their cleaned items
  []Entity cleanup for invalid, duplicate, abandoned and out-of-bounds entities
  Per-chunk entity ceiling for the case where thousands of valid entities pile into one place
  Smart mob removal that protects named, tamed, leashed, ridden, equipped and plugin-created entities
  Vehicle limits and abandoned minecart/boat cleanup

Optimization

• 
  Mob AI optimizer — disables pathfinding for distant mobs
  Smart chunk unloading and directional preloading
  Explosion radius control and TNT chain-reaction prevention
  Elytra speed limits and Trident riptide cooldowns
  Smart scheduler that pauses low-priority tasks under load and runs emergency tasks faster
  Console log filter with regex patterns

Monitoring

• 
  []TPS across 1m / 5m / 15m windows, tick times, lag spike detection
  []Memory tracking and chunk load-rate monitoring
  []Performance history persisted to disk, surviving restarts — configurable interval and retention
  []Worst-hour-of-day detection so you can schedule restarts around your actual problem window

Commands

/lagxpert diagnose [chat|refresh] Find what is causing lag and where
/lagxpert status Live performance dashboard
/lagxpert optimize Full optimization pass, before/after
/lagxpert emergency [status|force-normal] Emergency state control
/lagxpert profile [list|<name>|revert] Apply optimization profiles
/lagxpert inspect <x> <z> [world] Inspect a specific chunk
/lagxpert reload Hot-reload everything, no restart
/lagxpertgui [open|diagnostics] Interactive GUIs
/chunkstatus Your current chunk's usage
/tps [summary|detailed|memory|chunks|lagspikes|history|reset]
/clearitems [all|<world>] Manual item cleanup
/abyss Recover cleaned items

Permissions

lagxpert.use Basic access (default: true)
lagxpert.admin Everything below (default: op)
lagxpert.admin.status Read-only dashboard
lagxpert.admin.diagnostics Read-only lag analysis
lagxpert.admin.diagnostics.teleport Teleport to a problem chunk
lagxpert.admin.optimize Run optimization (removes entities)
lagxpert.admin.emergency Emergency controls
lagxpert.admin.profile Apply profiles (rewrites configs)
lagxpert.gui GUI access
lagxpert.tps / .abyss / .chunkstatus Player-facing commands
lagxpert.bypass.* Bypass limits
lagxpert.limits.<type>.<N> Per-player custom limits

The fine-grained admin nodes exist so you can give a moderator read-only diagnostics without also handing them the ability to delete entities or rewrite your configuration.

Compatibility

Installation

1. 
   []Drop the

   .jar

   into

   plugins/

   []Restart your server to generate the configuration files
   []Run

   /lagxpert diagnose

   to see what's actually happening
   []Adjust the

   .yml

   files, or use

   /lagxpertgui

2. /lagxpert reload

   applies changes without a restart

Upgrading from v2.6.x? Replace the jar and restart once so the new configuration files generate. Your existing settings stay compatible and new keys use safe defaults.

lagshield.yml

is no longer used and can be deleted.

️ For Developers

// Count chunk contents
LagXpertAPI.countLivingEntitiesInChunk(chunk);
LagXpertAPI.countTileEntitiesInChunk(chunk, Material.HOPPER);
LagXpertAPI.getLimitForMaterial(Material.HOPPER);

// The limit actually being enforced right now, after adaptive scaling
AdaptiveThresholdEngine.getInstance().getEffectiveMobLimit(world);

// Server state, audit trail, history
EmergencyController.getInstance().getCurrentState();
ActionLogger.getInstance().getRecent(50);
PerformanceHistory.getInstance().getEntityTrend(6);

// Full diagnostics report (callback runs on the main thread)
LagDiagnosticsEngine.getInstance().requestReport(false, report -> {
report.getTopChunks(10);
report.getObservations();
});

// React to chunk overloads
@EventHandler
public void onChunkOverload(ChunkOverloadEvent event) { }

⭐ Why LagXpert

Completely free — no premium tier, no paywalled features, no "pro version"
Tells you the cause, not just the symptom
Acts on its own — detects, fixes, logs, and recovers without you watching
Genuinely Bedrock-compatible, with a text fallback that always works
Genuinely Folia-compatible, with per-region dispatch throughout
Zero dependencies — works the moment you drop it in
Open source — read every line before you trust it
Honest changelogs — known limitations are documented, not hidden

Links

• 
  []Source code: https://github.com/koyere/LagXpert
  []Support Discord: https://discord.gg/xKUjn3EJzR
• bStats: plugin ID

  25746

Ready to stop guessing?

Install LagXpert, run

/lagxpert diagnose

, and find out what your server has been doing to itself.