COWMODSКаталог модов

LagXpert Free

Modular lag management for every server.

Автор: KoyereDev1,5 тыс.1обновлён 7 сент. 2026 г.
УправлениеМобыОптимизация

Описание

LagXpert Free v2.7 — Autonomous Optimizer & Lag Diagnostics

LagXpert is a Minecraft server performance plugin with multi-platform support (Folia/Paper/Spigot/Bukkit) and Bedrock compatibility. It does two things: it optimizes automatically as load changes, and it tells you why your server is lagging and where.

Version Platforms Java Bedrock


What's New in v2.7

Lag Diagnostics

Most performance plugins tell you your TPS. The harder question is which build is doing this to me. /lagxpert diagnose answers that.

  • Ranks chunks relative to their limits, not by raw counts. A chunk with 40 mobs against a limit of 200 is fine. A chunk with 12 hoppers against a limit of 8 is the problem. Ranking by raw count surfaces the wrong chunks.
  • Uses the limits actually in force, so the report matches what players are experiencing right now.
  • Counts intervention history. A chunk the plugin has cleaned up twenty times in the last hour ranks above one that is merely full.
  • Explains itself in plain language. Whether load is concentrated in a few chunks or spread everywhere, which violation type dominates, whether memory pressure is the real culprit, which world carries the load — and when the cause is outside LagXpert's scope, so you stop looking in the wrong place.
  • Diagnosing lag does not 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.

An interactive GUI provides five screens: overview, paginated hotspot list, per-chunk drill-down with a teleport button, the corrective-action audit trail, and historical trends.

Bedrock-first GUI rendering

Bedrock support here is structural, not cosmetic. Screen sizes come from the configured safe size and every slot position is computed from that actual size, so nothing is placed where a Bedrock client cannot render it. Materials Geyser translates badly are substituted automatically, lore is capped, and if an inventory cannot be opened at all the full report is delivered as chat text.

Emergency Controller

A four-level state machine (NORMAL → WARNING → CRITICAL → EMERGENCY) with hysteresis to prevent flapping. Each state applies graduated, configurable responses: mob cap reduction, natural spawn blocking, forced item cleanup, aggressive chunk unloading, AI distance reduction, redstone clock shutdown, server-wide AI freeze, and optional custom commands.

In v2.7 the EMERGENCY tier became reachable and the last four responses became functional — previously they were configurable and displayed but never executed.

Adaptive Thresholds

Every per-chunk limit scales with server health. Two inputs are combined: continuous health from TPS and memory, and the discrete emergency state. The more restrictive of the two wins; they are never multiplied, which would compound into unplayable values. Limits are only ever scaled down — your configured value is always the ceiling — with a configurable floor. Per-player limits granted via lagxpert.limits.* permissions are honored verbatim.

Optimization Profiles

Four presets (relaxed, balanced, aggressive, performance) applied with /lagxpert profile <name>. Applying a profile snapshots the values it replaces, so revert restores your configuration rather than an assumed default. auto-revert-minutes guards against applying an aggressive profile during an incident and forgetting about it.


Features

Autonomous optimization

  • Emergency Controller with graduated per-state responses
  • Adaptive limits for mobs, storage, entities and redstone
  • Smart scheduler that adjusts task intervals by state and priority: low-priority tasks pause during WARNING, emergency-priority tasks run up to 4x faster
  • Closed loop: detect → act → log
  • Full audit trail of every corrective action, queryable in-game

Diagnostics & monitoring

  • Ranked chunk hotspot analysis with plain-language conclusions
  • Interactive diagnostics GUI with teleport-to-hotspot
  • TPS across 1/5/15-minute windows, tick times, lag spike detection
  • Performance history with configurable interval and retention, persisted to disk
  • Worst-hour-of-day detection, peak player tracking, entity growth trends

Limits & cleanup

  • Per-chunk limits for mobs, hoppers, chests, furnaces, barrels, droppers, dispensers, shulker boxes, TNT, pistons and observers
  • Redstone circuit tracking with flood-fill circuit breaker
  • Item cleaner with warnings and the Abyss recovery system
  • Entity cleanup: invalid, duplicate, abandoned, out-of-bounds, and chunks over the entity ceiling
  • Smart mob removal protecting named, tamed, leashed, ridden and equipped entities
  • Mob AI optimizer (distance-based and per-type)
  • Explosion radius control and chain-reaction prevention
  • Vehicle limits and abandoned vehicle cleanup
  • Elytra speed limit and Riptide cooldown
  • Thread-safe console log filter

Administration

  • Interactive GUI configuration (/lagxpertgui)
  • Per-world configuration overrides
  • Hot reload covering every subsystem
  • bStats metrics integration

Modules & Config Files

ModuleConfig FileDescription
Generalconfig.ymlModule toggles, adaptive thresholds, action logger, performance history
Mobsmobs.ymlMob limits, AI optimizer, smart removal
Storagestorage.ymlBlock limits per chunk
Redstoneredstone.ymlCircuit tracking, flood-fill breaker
Alertsalerts.ymlNotification toggles, cooldowns, rate limits
Task Scannertask.ymlAuto-chunk scan interval
Item Cleaneritemcleaner.ymlGround item cleanup + Abyss recovery
Entity Cleanupentitycleanup.ymlEntity removal targets, per-chunk entity ceiling
Monitoringmonitoring.ymlTPS, memory, chunk, lag spike thresholds
Chunkschunks.ymlChunk loading/unloading, preloading
Emergency Controlleremergency-controller.ymlState thresholds, graduated responses
Vehiclesvehicles.ymlVehicle limits, abandoned cleanup
Abilitiesabilities.ymlElytra speed, Riptide cooldown
Explosionsexplosions.ymlExplosion radius, chain reaction prevention
Console Filterconsole-filter.ymlConsole log regex filters
Profilesprofiles.ymlOptimization presets
Messagesmessages.ymlAll plugin messages (i18n)

Commands

CommandDescriptionPermission
/lagxpertMain command and helplagxpert.use
/lagxpert diagnose [chat|refresh]Find what is causing lag and wherelagxpert.admin.diagnostics
/lagxpert statusPerformance dashboardlagxpert.admin.status
/lagxpert optimizeFull optimization pass with before/afterlagxpert.admin.optimize
/lagxpert emergency [status|force-normal]Emergency state controllagxpert.admin.emergency
/lagxpert profile [list|<name>|revert]Apply optimization profileslagxpert.admin.profile
/lagxpert reloadHot-reload all configurations and subsystemslagxpert.admin
/lagxpert inspect <x> <z> [world]Inspect a specific chunklagxpert.admin
/lagxpertgui [open|diagnostics]Interactive GUIslagxpert.gui
/chunkstatusCurrent chunk usage infolagxpert.chunkstatus
/tpsServer performance metricslagxpert.tps
/abyssRecover recently cleared itemslagxpert.abyss
/clearitems [all|world]Manual item cleanuplagxpert.clearitems

Permissions

lagxpert.admin implies every lagxpert.admin.* node. The finer nodes exist so a limited admin can be granted one capability without the rest — for example read-only diagnostics without the ability to rewrite configs or remove entities.

PermissionDefaultDescription
lagxpert.usetrueBasic command access
lagxpert.adminopAll administrative commands
lagxpert.admin.statusopRead-only performance dashboard
lagxpert.admin.diagnosticsopRead-only lag analysis and diagnostics GUI
lagxpert.admin.diagnostics.teleportopTeleport to a problem chunk from the GUI
lagxpert.admin.optimizeopRun optimization (removes entities, unloads chunks)
lagxpert.admin.emergencyopEmergency controls, including force-normal
lagxpert.admin.profileopApply profiles (rewrites config files)
lagxpert.guiopGUI access
lagxpert.chunkstatustrueChunk status command
lagxpert.tpstrueTPS command
lagxpert.abysstrueItem recovery
lagxpert.clearitemsopManual cleanup
lagxpert.emergency.notifyopReceive emergency state broadcasts
lagxpert.monitoring.alertsopReceive performance alerts
lagxpert.alerts.receiveopReceive all limit alerts
lagxpert.bypass.mobsfalseBypass mob limits and emergency spawn blocking
lagxpert.bypass.redstonefalseBypass redstone control
lagxpert.bypass.abilitiesfalseBypass ability limits
lagxpert.bypass.*falseBypass all limits
lagxpert.limits.mobs.<N>falseCustom mob limit for a player or rank
lagxpert.limits.hoppers.<N>falseCustom hopper limit for a player or rank
lagxpert.notifications.mob-removalfalseReceive nearby mob removal notifications
lagxpert.console.view-filteredfalseReceive suppressed console messages in chat

Installation

  1. Drop LagXpert-2.7.jar into plugins/
  2. Start the server to generate configuration files
  3. Run /lagxpert diagnose to see your server's current state
  4. Adjust the .yml files as needed
  5. /lagxpert reload to apply changes without a restart

Upgrading from v2.6.x

  1. Stop the server and replace the jar
  2. Restart so emergency-controller.yml and profiles.yml are generated
  3. Existing configs remain compatible; new keys use safe defaults
  4. lagshield.yml is no longer used and can be deleted

Requirements

  • Java 11+
  • Minecraft 1.16+ (Spigot / Paper / Purpur / Folia)
  • No required dependencies. Geyser and Floodgate are optional soft dependencies used for Bedrock player detection.

Developer API

// React to chunk overloads
@EventHandler
public void onChunkOverload(ChunkOverloadEvent event) {
    event.getChunk();
    event.getCause();
}
// Count contents of a chunk
LagXpertAPI.countLivingEntitiesInChunk(chunk);
LagXpertAPI.countTileEntitiesInChunk(chunk, Material.HOPPER);
LagXpertAPI.countAllShulkerBoxesInChunk(chunk);

// Read configured limits
LagXpertAPI.getMobLimit();
LagXpertAPI.getHopperLimit();
LagXpertAPI.getLimitForMaterial(Material.HOPPER);   // -1 if unmanaged

Because limits are dynamic in v2.7, LagXpertAPI returns the configured value. For the limit currently being enforced, go through the adaptive engine:

AdaptiveThresholdEngine adaptive = AdaptiveThresholdEngine.getInstance();

// Limit in force right now, after health and emergency scaling
adaptive.getEffectiveMobLimit(world);
adaptive.getEffectiveLimit(LimitCategory.STORAGE, ConfigManager.getMaxHoppersPerChunk(world));
adaptive.isCurrentlyThrottling();
// Server state, audit trail and history
EmergencyController.getInstance().getCurrentState();
ActionLogger.getInstance().getRecent(50);
PerformanceHistory.getInstance().getEntityTrend(6);

// Diagnostics report (callback runs on the main thread)
LagDiagnosticsEngine.getInstance().requestReport(false, report -> {
    if (report == null) return;              // a scan was already running
    report.getTopChunks(10);
    report.getObservations();
});

Per-world overrides

Drop a file named after your world into plugins/LagXpert/config/worlds/ to override global settings for that world only. Requires per-world-settings.enabled: true in config.yml.

Supported paths:

limits:
  mobs-per-chunk, hoppers-per-chunk, chests-per-chunk, furnaces-per-chunk,
  blast_furnaces-per-chunk, smokers-per-chunk, barrels-per-chunk,
  droppers-per-chunk, dispensers-per-chunk, shulker_boxes-per-chunk,
  tnt-per-chunk, pistons-per-chunk, observers-per-chunk

entity-cleanup:
  advanced:
    max-entities-per-chunk      # total entity ceiling for this world

chunk-management:
  auto-unload:
    inactivity-threshold-minutes
  preload:
    enabled

monitoring:
  tps:
    alert-thresholds:
      warning, critical

Anything omitted falls back to the global value. Per-world values are still scaled down by the adaptive engine under load.

A limit of 0 means "no limit", not "ban". Use 1 for the strictest possible restriction.


Folia support

Folia splits the server into independently ticking regions, and an entity may only be touched by the thread that owns its chunk. LagXpert honors that: every operation that reads or removes entities is dispatched per chunk through the region scheduler. This covers the item cleaner, entity cleanup, vehicle cleanup, per-chunk entity trimming, the emergency AI freeze, the diagnostics scan, and even entity counting for snapshots and the optimize report.

On Spigot and Paper the same dispatch runs chunks in batches across ticks, which turns one long stalling tick into several short ones. That matters because these sweeps run precisely when the server is already under pressure.

A consequence is that cleanup totals arrive when a sweep finishes rather than instantly, so /clearitems and /lagxpert optimize report their results on completion.


Known limitations

  • There is no automated test suite; verification is performed against the built artifact.
  • /lagxpert optimize reports TPS as a rolling average rather than a before/after delta, because the average cannot move within the span of the command.

Support

Discord: https://discord.gg/xKUjn3EJzR bStats Plugin ID: 25746

Галерея

Последние версии

Все версии →
release

Autonomous Optimizer & Lag Diagnostics

2.7
7 сент. 2026 г.160Minecraft: 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7, 1.21.8, 1.21.9, 1.21.10, 1.21.11, 26.1, 26.1.1, 26.1.2, 26.2bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.7 — Autonomous Optimizer & Lag Diagnostics This release does two things: it makes the automatic optimization actually run, and it adds a diagnostics system that tells you *why* your server is lagging and *where*. The honest framing matters here. Parts of v2.6 shipped configuration that was read, displayed in commands, and then never acted upon. This release closes those gaps and adds verification so they cannot silently reopen. ## 🔍 Lag Diagnostics (new) The most common admin question is not "what is my TPS" — it is "which build is doing this to me". v2.7 answers that directly. `/lagxpert diagnose` scans every loaded chunk and produces a ranked report: - **Scoring is relative to limits, not raw counts.** A chunk with 40 mobs where the limit is 200 is fine. A chunk with 12 hoppers where the limit is 8 is a problem. Ranking by raw count surfaces the wrong chunks, so every metric contributes its percentage of the limit that actually applies to that world. - **Intervention history counts.** A chunk LagXpert has had to clean up twenty times in the last hour ranks above one that is merely full right now. - **Limits come from the live adaptive engine**, so the report reflects what is being enforced at that moment, matching what players experience. - **Plain-language conclusions**, not just numbers. The report tells you whether load is concentrated in a few chunks or spread everywhere, which violation type dominates, whether memory pressure is the real cause, which world is carrying the load, and — importantly — when the cause is *outside* LagXpert's scope so you stop looking in the wrong place. Scanning is two-phase: chunk snapshots are gathered on the owning thread, then all scoring happens asynchronously. Diagnosing lag must not cause lag. Reports are cached for 30 seconds so a command and a GUI opened together share one scan, and concurrent scans are rejected rather than queued. ### Diagnostics GUI `/lagxpert diagnose` in-game opens an interactive interface with five screens: - **Overview** — server state, TPS across three windows, memory, entity totals per world, the plain-language diagnosis, and the limits currently in force. - **Hotspots** — paginated ranked chunk list, colour-coded by severity, each showing which metrics are over limit. - **Chunk detail** — every measured contributor for one chunk, plus a teleport button to go look at it. - **Corrective actions** — the audit trail, with timestamps, triggers and counts. - **Trends** — worst hour of the day, peak players, entity growth direction and 24h projection. ### Bedrock compatibility This was built Bedrock-first rather than retrofitted: - Screen sizes come from `BedrockPlayerUtils.getSafeInventorySize`, and **every slot position is computed from the actual size**. Nothing is placed in a slot a Bedrock client will never render. - Materials that Geyser translates badly (spawn eggs, command blocks, structure blocks, knowledge books) are substituted automatically. - Lore is capped at 10 lines, past which Bedrock truncates tooltips unpredictably. - Legacy `&` colour codes only. - **If the inventory cannot be opened at all, the full report is sent as chat text.** A Bedrock admin is never left without a diagnosis. The Bedrock rules now live in one shared helper (`BedrockUI`) that both the config GUI and the diagnostics GUI route through, so they cannot drift apart. The previous `BedrockCompatibleGUI` class — 574 lines that registered no listener and had no callers — has been removed rather than left as a maintenance trap. ## 🚨 Emergency Controller A four-level state machine (NORMAL → WARNING → CRITICAL → EMERGENCY) with hysteresis: 3 consecutive bad readings to escalate, 5 good to de-escalate, minimum 10 seconds per state. **The EMERGENCY tier is now reachable.** In the pre-release code `computeTargetState()` could only ever return NORMAL, WARNING or CRITICAL, which made the entire `responses.emergency` block — the 25% mob cap, the 16-block AI distance, the 1-minute unload threshold, and the custom command list — permanently dead. It now escalates via dedicated `thresholds.tps.emergency` / `thresholds.ram.emergency` values, and also on sustained CRITICAL: a server pinned at 12 TPS for two minutes is an emergency in practice even if it never crosses the raw threshold. Threshold ordering is validated at startup. Misconfiguring the tiers so one becomes unreachable now logs a warning instead of failing silently. ### Responses that now actually execute | Response | Status | |---|---| | Mob cap multiplier (75% / 50% / 25%) | working | | Chunk preloader pause | working | | Aggressive chunk unloading | working | | AI distance reduction | working | | Redstone clock shutdown | working | | **Block natural spawns** | **now implemented** | | **Forced item cleanup** | **now implemented** | | **Server-wide AI freeze** | **now implemented** | | **Emergency commands** | **now reachable** | The last four were configurable and reported by `/lagxpert emergency` but had no code acting on them. A new response coordinator consumes them: - **Natural spawn blocking** filters by `SpawnReason`. Only environmental pressure is suppressed — spawn eggs, breeding, plugin spawns and commands keep working, because blocking those makes a server look broken rather than busy. The list is operator-configurable, and players with `lagxpert.bypass.mobs` are exempt. - **Forced cleanup** runs off-cycle with a CAS latch and a cooldown, so a flapping state cannot stack cleanup sweeps. - **AI freeze** dispatches per chunk (correct under Folia), skips players and NPC-metadata entities, and on recovery respects your `mobs.yml` AI rules instead of blanket re-enabling everything. A shutdown mid-emergency lifts the freeze so mobs are never left permanently frozen. ## 📊 Adaptive Thresholds Previously this computed multipliers correctly and **nothing consumed them** — turning the feature on or off only changed numbers in `/lagxpert status`. It is now the single authority for "what is the limit right now", and is wired into: - `StorageListener` — hopper, chest, furnace, barrel, dropper, dispenser, shulker, TNT, piston and observer placement limits - `EntityListener` and `SmartMobManager` — mob caps - `RedstoneCircuitTracker` — pulse tolerance and maximum circuit duration - `AutoChunkScanTask` — so a chunk flagged as overloaded matches what players are actually restricted to - `EntityCleanupTask` — the per-chunk entity ceiling Two independent inputs are combined: continuous server health (from TPS and memory) and the discrete emergency state. **The more restrictive of the two wins; they are never multiplied**, which would compound into unplayable values. Limits are only ever scaled *down* — your configured value is always the ceiling — and a configurable `minimum-multiplier` floor prevents collapse. Per-player limits granted through `lagxpert.limits.*` permissions are honored verbatim and never scaled. The health factor now takes the **worse** of the TPS and memory components rather than averaging them, so healthy memory can no longer mask a genuinely bad TPS reading. ## 📋 Optimization Profiles `profiles.yml` previously shipped with **zero Java code behind it**: no reader, no `profile` subcommand. `/lagxpert profile balanced` returned "unknown subcommand". Now implemented: ``` /lagxpert profile list show profiles and which is active /lagxpert profile <name> apply a profile /lagxpert profile revert restore the pre-profile configuration ``` Applying a profile writes into the real config files, saves them, and reloads every subsystem. Before the first write the replaced values are snapshotted, so `revert` restores **your** configuration rather than an assumed default — and applying a second profile over a first still reverts all the way back. `safety.auto-revert-minutes` guards against applying an aggressive profile during an incident and forgetting. Profile keys that do not map to a real setting are reported in the console instead of being silently dropped. The unmappable `redstone.disable-clocks` key has been replaced with keys that exist. ## 🔧 Other fixes - **`/lagxpert reload` now reloads everything.** It previously refreshed only `ConfigManager` and `AbyssManager`; a dozen subsystems read their own YAML at construction and kept startup values until a full restart. All are now covered, with per-subsystem failure isolation so one bad section cannot abort the reload. - **`entity-cleanup.advanced.max-entities-per-chunk` is now enforced.** It was read into a field and never used. A new pass trims chunks over the ceiling, respecting every existing protection rule (named, tamed, leashed, ridden, persistent, plugin-created, villagers with trades). - **`MobAIOptimizer` honors its own config again.** It was reading the emergency controller's getter, which returns a hardcoded 64 when the controller is disabled — so your `mobs.yml` distance was ignored entirely. The controller may now only *tighten* the configured radius, never widen it. - **`plugin.yml` corrected.** `folia-supported: true` added (without it Folia refuses to load the plugin regardless of the code). Geyser and Floodgate declared as soft dependencies so Bedrock detection works on first join rather than after a reconnect. The `lagxpert.admin.*` permission nodes are now declared — previously they were checked but undeclared, so an admin holding only `lagxpert.admin` saw commands advertised in help and then got "no permission". - **Permission checks unified.** Help output, tab completion and command execution now consult one method, ending the mismatch between what was advertised and what could be run. - **`/lagxpert optimize` reports honestly.** Chunk unloading now runs inline and returns a real count instead of dispatching asynchronously and always reporting zero. Before/after values are coloured by whether they actually improved rather than always green. The hardcoded cache-clear count of 1 is gone, and TPS is labelled as a rolling average instead of showing a meaningless same-tick delta. - **`/lagxpert status` is fully translatable.** Its output was hardcoded English; it now uses `messages.yml` like the rest of the plugin, and additionally shows which emergency responses are in force and which profile is active. - **Performance history honors its config.** `snapshot-interval-seconds` and `max-history-days` were documented but ignored in favour of hardcoded constants. Saved history is also loaded during startup now, rather than reappearing only after the first interval elapsed. - **Bedrock player cache no longer leaks.** Entries are evicted on disconnect. Detection also identifies Floodgate UUIDs structurally instead of by string prefix, and re-initialises if Geyser or Floodgate finished loading after LagXpert. - **`LagShield` removed.** It was a deprecated passthrough with no callers; `lagshield.yml` was shipped in the JAR but never written or read. Both are gone, along with the legacy message keys. ## ⚙️ Configuration New in `emergency-controller.yml`: ```yaml thresholds: tps: emergency: 10.0 # new tier critical: 15.0 warning: 18.0 recovery: 19.0 stability: # Escalate to EMERGENCY after this long stuck in CRITICAL, even if the # raw metrics never cross the emergency thresholds. 0 disables. sustained-critical-escalate-seconds: 120 actions: forced-item-cleanup: enabled: true cooldown-seconds: 60 # stops a flapping state stacking cleanups block-natural-spawns: spawn-reasons: [NATURAL, SPAWNER, CHUNK_GEN, ...] ai-freeze: enabled: true ``` New in `config.yml`: ```yaml adaptive-thresholds: enabled: true sensitivity: mobs: 1.0 storage: 0.7 # don't disrupt player builds entities: 1.0 redstone: 1.0 # Limits can never drop below this fraction of your configured value minimum-multiplier: 0.25 health: healthy-tps: 20.0 degraded-tps: 10.0 healthy-memory-percent: 50.0 degraded-memory-percent: 95.0 ``` ## 📦 Commands & Permissions | Command | Permission | Purpose | |---|---|---| | `/lagxpert diagnose [chat\|refresh]` | `lagxpert.admin.diagnostics` | Find what is causing lag and where | | `/lagxpert status` | `lagxpert.admin.status` | Live dashboard | | `/lagxpert optimize` | `lagxpert.admin.optimize` | Full optimization pass | | `/lagxpert emergency [status\|force-normal]` | `lagxpert.admin.emergency` | Emergency state control | | `/lagxpert profile [list\|<name>\|revert]` | `lagxpert.admin.profile` | Apply optimization profiles | | `/lagxpertgui diagnostics` | `lagxpert.admin.diagnostics` | Diagnostics GUI directly | `lagxpert.admin` implies all of the above. The finer nodes can be granted individually — useful for giving a moderator read-only diagnostics without the ability to rewrite configs or remove entities. Teleporting to a hotspot requires `lagxpert.admin.diagnostics.teleport`. ## Installation ### Fresh install 1. Drop `LagXpert-2.7.jar` into `plugins/`. 2. Start the server to generate configuration files. 3. Run `/lagxpert diagnose` to see your server's current state. ### Upgrade from v2.6.x 1. Stop the server. 2. Replace the old jar with `LagXpert-2.7.jar`. 3. **Restart** to generate `emergency-controller.yml` and `profiles.yml`. 4. Your existing configs remain compatible. New keys use safe defaults. 5. `lagshield.yml` is no longer used and can be deleted. After upgrading, `/lagxpert reload` applies config edits without a restart — including `emergency-controller.yml`, which previously required one. ### Compatibility - **Minecraft**: 1.16.x – 26.2 - **Platforms**: Spigot, Paper, Purpur, Folia - **Java**: 11 or higher - **Bedrock**: Geyser & Floodgate ## A note on verification Because the recurring problem in v2.6 was configuration that looked live but was not, this release was checked against that specific failure mode: - Every previously-dead method was confirmed to have real production call sites. - All 21 shipped YAML files were parsed to confirm they load. - All 21 profile key mappings were confirmed to resolve to real config paths. - The emergency state machine was exercised to confirm all four states are reachable from realistic metrics via both the TPS and memory paths. - All 84 message keys referenced in code were confirmed to exist in `messages.yml`. ### Per-world overrides that were silently ignored - **`max-entities-per-chunk`** had no world-aware resolution, so the nether template's `150` was discarded in favour of the global `200`. - **`tnt-per-chunk`, `pistons-per-chunk`, `observers-per-chunk`** had resolvers in `WorldConfigManager` that nothing ever called: `ConfigManager` exposed no `World`-argument delegate for them, and both the placement listener and the chunk scanner used the global value. All four now resolve per world in the placement listener, the chunk scanner, the entity cleanup pass and the diagnostics engine. All 18 world-aware paths were confirmed to have a valid global fallback, and the shipped nether and end templates each apply 6 active overrides. The nether template also shipped `tnt-per-chunk: 0` commented as "No TNT in nether by default", but `0` means *no limit* throughout the plugin. Once per-world TNT resolution started working, that would have granted the nether unlimited TNT while claiming the opposite. Corrected to `1` in all three places the template is generated, with the `0` semantics now documented. ### Folia correctness of cleanup sweeps Folia gives each region its own ticking thread, and an entity may only be touched by the thread that owns its chunk. No thread is permitted to sweep an entire world. The cleanup tasks did exactly that, via `world.getEntities()` and `world.getEntitiesByClass()`. A new `RegionizedSweeper` utility enumerates loaded chunks and performs the work on the owning thread. Converted to it: - the item cleaner (scheduled, manual, per-world and emergency-forced) - entity cleanup, including the per-chunk entity ceiling pass - vehicle cleanup - entity counting for performance snapshots and the optimize report On Spigot and Paper the same dispatch processes chunks in batches across ticks, turning one stalling tick into several short ones — a genuine improvement, since these sweeps run precisely when the server is already struggling. Per-cycle removal budgets are shared across the whole sweep via atomic counters. Because sweeps now complete asynchronously, `/clearitems` and `/lagxpert optimize` report their totals on completion. The optimize phases are chained so each begins only after the previous one finishes, which keeps counts attributable to the right phase and prevents three concurrent sweeps competing for the same budgets. Verified: no whole-world entity access remains outside comments, and all four entity removal sites sit inside chunk-scoped, sweeper-dispatched methods. ### Known limitations - There is no automated test suite. The verification above was performed against the built artifact, not as regression tests. - `/lagxpert optimize` reports TPS as a rolling average rather than a before/after delta, because the average cannot move within the span of the command.
release

Bug Fixes

2.6.1
3 мар. 2026 г.320Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7, 1.21.8, 1.21.9, 1.21.10, 1.21.11bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.6.1 - Hotfix ## 🐛 Bug Fixes ### Fixed: Limit messages showing raw YAML objects Players were seeing `MemorySection[path='limits.hopper', root='YamlConfiguration']` instead of actual alert messages when placing blocks near or at chunk limits. **What changed:** - `messages.yml` now uses a structured format with `full` and `short` sub-keys per message. - ActionBar restriction messages now properly use the short variant. **Action required:** Delete your existing `plugins/LagXpert/messages.yml` and restart the server to regenerate it, or manually update the `limits:` section to use the new `full`/`short` structure. ### Fixed: `IllegalArgumentException: Specified map is empty` in AsyncChunkAnalyzer Server log was spamming this error when analyzing chunks with no tile entities (empty chunks, deserts, oceans, etc.). **Action required:** None. Just update the JAR. ### Fixed: `Missing message: lagshield.activated` in console LagShield was looking for messages at the wrong path in `messages.yml`. **Action required:** None. Just update the JAR. ## ✨ Improvements ### Translatable block and entity names in statistics All block and entity names shown in `/chunkstatus`, `/lagxpert inspect`, chunk scan alerts, and near-limit warnings are now fully customizable from `messages.yml`. A new `translations:` section lets you rename items like "Hoppers", "Chests", "Mobs", etc. to match your server's language. The `/chunkstatus` display is also fully customizable with individual line formats. **Action required:** Delete your existing `plugins/LagXpert/messages.yml` and restart the server to regenerate it with the new `translations:` and `chunkstatus:` sections. Then edit the names to your language. ### Fixed: Chests and Trapped Chests duplicated in scan statistics Chests and Trapped Chests were showing as two separate entries in chunk overload alerts, even though they share the same limit. They are now combined into a single "Chests" entry. Same fix applied to Pistons/Sticky Pistons. ### Fixed: Entity cleanup message showing raw color codes The entity cleanup broadcast message (`&a`, `&e`, etc.) was not being translated to actual colors, showing raw codes like `&e18&a` in chat. ## 📦 Upgrade 1. Replace `LagXpert-2.6.jar` with `LagXpert-2.6.1.jar`. 2. Delete `plugins/LagXpert/messages.yml` (will regenerate on startup with new translation options). 3. Restart the server. 4. Edit the `translations:` section in `messages.yml` to your language.
release

Reactive Optimization & Modular Control

2.6
23 дек. 2025 г.237Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7, 1.21.8, 1.21.9, 1.21.10, 1.21.11bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.6 - Reactive Optimization & Modular Control This update introduces advanced modules for proactive performance management, including AI optimization, lag shields, and specific controls for vehicles and explosions. ## 🚀 Highlights - **MobAIOptimizer**: Intelligent system that disables AI and pathfinding for mobs in loaded chunks to drastically reduce CPU usage. - **LagShield**: Emergency monitor that automatically activates severe restrictions when TPS drops below 16.0 or RAM exceeds 90%. - **ExplosionController**: Full control over TNT, Creeper, and Wither explosions. Includes radius limits and prevention of massive chain reactions. - **VehicleManager**: Configurable per-chunk limits for minecarts and boats, with automatic cleanup of abandoned vehicles. - **AbilityLimiter & ConsoleFilter**: Speed restrictions for Elytras, cooldowns for Tridents, and Regex-based console spam filtering. ## ⚙️ Configuration Examples **`explosions.yml`** - Prevent massive TNT chain reactions: ```yaml settings: prevent-chain-reaction: true max-primed-tnt-per-chunk: 20 disable-explosion-drops: false ``` **`vehicles.yml`** - Limit entities per chunk: ```yaml limits: minecarts: per-chunk: 8 boats: per-chunk: 5 ``` ## 🐛 Bug Fixes & Technical Improvements - **Modular Refactoring**: Clean implementation of new systems (`me.koyere.lagxpert.system.*`) with independent configurations. - **Compilation Fixes**: Resolved symbol error in `VehicleManager` and cleaned up imports in `AbilityLimiter`. - **Secure Integration**: Verified build with Maven (`BUILD SUCCESS`) and ensured correct registration of listeners and commands. ## 📦 Installation & Compatibility ### Installation 1. Stop your server. 2. Delete any previous `LagXpert-*.jar` versions. 3. Place the new `LagXpert-2.6.jar` in your `/plugins/` folder. 4. **Restart the server.** This is required to automatically generate the new configuration files: - `mobs.yml`, `lagshield.yml`, `explosions.yml`, `vehicles.yml`, `abilities.yml`, `console-filter.yml`. 5. *Note: While `/lagxpert reload` exists, a full restart is strongly recommended for this update to ensure all new modules initialize correctly.* ### Compatibility - **Versions**: Minecraft 1.16.x - 1.21.x - **Platforms**: Spigot, Paper, Purpur, Folia (Experimental support). - **Java**: Java 17 or higher recommended.
release

World-Aware Enforcement & Activity Tracking

2.5
14 окт. 2025 г.233Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7, 1.21.8, 1.21.9, 1.21.10bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.5 - World-Aware Enforcement & Activity Tracking ## 🚀 Highlights - **Per-world enforcement**: Mob spawns, storage placement checks and automated scans now honour world-specific overrides, keeping creative hubs relaxed and survival worlds strict. - **Config-driven grace periods**: The item cleaner reads `broken-block-tracking` (default + material overrides) directly from `itemcleaner.yml`, making temporary drop protection fully customisable. - **Chunk safeguards from config**: Smart chunk management now loads the important-block list from `chunks.yml`, so mission-critical structures stay loaded without code changes. ## ⚙️ Technical Improvements - Hooked chunk activity tracking into block/entity/player events and scheduled periodic cleanup to keep telemetry fresh. - Added Folia/Bukkit-safe activity cleanup task and listener to populate `ChunkManager`’s analytics in real time. - Introduced world-aware limit providers across listeners, smart mob manager and the auto chunk scanner. - Implemented configurable alert skipping when no players are online, aligned with `monitoring.yml`. ## 🛠 Developer Notes - `ConfigManager` exposes per-world getters and broken block tracking settings; `RecentlyBrokenBlocksTracker.configure(...)` keeps runtime state in sync. - Added `ChunkActivityListener` and `ChunkActivityCleanupTask` to the lifecycle; ensure they remain registered when extending the chunk management module.
release

Action Bar Notifications Update

2.4
7 июл. 2025 г.160Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.4 - Action Bar Notifications Update ## 🎯 New Features ### Action Bar Messages - **Restriction messages now appear in the action bar** instead of chat spam - Clean, non-intrusive notifications when you try to place blocks above limits - Messages automatically disappear after a few seconds ### Enhanced User Experience - **Shorter cooldowns** for action bar messages (5 seconds instead of 15) - **Compact message format** optimized for action bar display - **Fallback system** - if action bar fails, messages still appear in chat ## ⚙️ Configuration Options ### New Settings in `messages.yml` ```yaml delivery: restrictions: method: "actionbar" # Options: "chat", "actionbar", "both" cooldown: 5 # Seconds between messages ``` **Available Methods:** - `"chat"` - Traditional chat messages (old behavior) - `"actionbar"` - Action bar only (new default) - `"both"` - Send to both chat and action bar ### Message Customization - All restriction messages now have short versions for action bar - You can still customize both long and short message formats - No configuration changes required - works with existing setups ## 🔧 What This Means for You ### For Players - **Less chat spam** when building near limits - **Cleaner interface** with subtle notifications - **Same functionality** - all limits work exactly the same ### For Server Admins - **Reduced chat noise** in logs and screenshots - **Better user experience** for builders - **Fully configurable** - switch back to chat if preferred ## 🐛 Bug Fixes ### Block Limit Issues Resolved - **Fixed off-by-one error** - Players can now place the full configured amount of blocks - Previously: Limit of 10 only allowed 9 blocks - Now: Limit of 10 correctly allows 10 blocks - **Fixed colored shulker boxes** - All 16 colored shulker box variants are now properly limited - Previously: Only purple shulker boxes were detected - Now: All colored shulker boxes count toward the same limit ### Affected Blocks - **TNT, Hoppers, Pistons** - No longer stop 1 block short of limit - **All Shulker Boxes** - White, Orange, Magenta, Light Blue, Yellow, Lime, Pink, Gray, Light Gray, Cyan, Purple, Blue, Brown, Green, Red, Black ## 🔒 Privacy & Permissions ### Alert Privacy System - **Alert filtering by permissions** - Only players with permission receive limit alerts - **No more base location reveals** - Prevents accidental discovery of hidden builds - **Configurable alert access** - Admins can control who sees what alerts ### Custom Limit Permissions - **Per-player custom limits** - Set different limits for different players/ranks - **Permission-based limits** - Use permissions like `lagxpert.limits.hoppers.25` - **Priority system** - Bypass > Custom limit > Default limit ### New Permission Examples ``` lagxpert.alerts.receive - Receive all alerts lagxpert.alerts.blocks - Receive block limit alerts only lagxpert.limits.hoppers.15 - Allow 15 hoppers instead of default lagxpert.limits.mobs.50 - Allow 50 mobs instead of default ``` ## 🛠️ Technical Notes - **Backward Compatible** - All existing configurations work unchanged - **Automatic Migration** - No manual config updates needed - **Spigot 1.16.5+** - Compatible with all supported Minecraft versions --- *This update improves the user experience while maintaining all existing functionality. Players will notice cleaner, less intrusive notifications when working with block limits, and limits now work exactly as configured.*
release

Performance & Reliability Update

2.3
4 июл. 2025 г.48Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5, 1.21.6, 1.21.7bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.3 - Performance & Reliability Update ## 🚀 What's New ### Major Performance Improvements - **Atomic Counter System**: Implemented high-performance atomic counters for TNT and block tracking, replacing expensive chunk scanning operations - **Pre-Placement Validation**: Enhanced block placement validation to prevent race conditions and improve reliability - **Smart Alert System**: Added intelligent alert filtering to reduce spam when no players are online ### Enhanced Item Cleaner System - **Recently Broken Block Tracking**: New system tracks when players break blocks and provides grace periods for dropped items - **Material-Specific Grace Periods**: Configurable grace periods for valuable materials (diamonds, emeralds, spawners, etc.) - **Intelligent Item Protection**: Prevents cleanup of items from recently broken blocks, solving the "mining diamonds but inventory full" scenario ### Bug Fixes - **Fixed TNT Limit Bypass**: Resolved critical race condition that allowed TNT placement after 3-4 attempts despite limits - **Improved Thread Safety**: Enhanced concurrent access handling for block counters and cache operations - **Alert Frequency Fix**: Resolved issue with alerts being sent every 2 minutes even when players are online ## 🔧 Technical Improvements ### Performance Optimizations - **O(1) Block Counting**: TNT and piston counting now uses atomic operations instead of O(n) chunk scanning - **Reduced Memory Usage**: Optimized cache invalidation and cleanup processes - **Async Processing**: Enhanced asynchronous chunk analysis with better error handling ### Code Quality - **Better Error Handling**: Improved exception handling throughout the codebase - **Enhanced Logging**: Added detailed debug logging for troubleshooting - **Thread-Safe Operations**: Strengthened concurrent access patterns ## ⚙️ Configuration Updates ### New Configuration Options #### itemcleaner.yml ```yaml broken-block-tracking: enabled: true default-grace-period-seconds: 180 # 3 minutes custom-grace-periods: DIAMOND_ORE: 300 # 5 minutes for valuable ores EMERALD_ORE: 300 ANCIENT_DEBRIS: 300 CHEST: 600 # 10 minutes for storage blocks SPAWNER: 900 # 15 minutes for spawners ``` #### monitoring.yml ```yaml alerts: delivery: skip-when-no-players-online: true # Reduces alert spam ``` ## 🎯 User Experience Improvements ### For Server Administrators - **Reduced Log Spam**: Fewer unnecessary alerts when server is empty - **Better Performance Monitoring**: More accurate TPS and memory tracking - **Improved Debugging**: Enhanced debug logs for troubleshooting ### For Players - **Protected Valuable Items**: Mining diamonds and other valuables is now safer - **Reduced Frustration**: Items from recently broken blocks won't be cleaned immediately - **Better Performance**: Smoother gameplay due to optimized block limit checking ## 🛡️ Compatibility & Requirements ### Minecraft Compatibility - **Tested Versions**: 1.16.5 - 1.21.7 - **Newly Supported**: 1.21.6, 1.21.7 - **Server Software**: Spigot, Paper, Purpur, and forks ### Java Requirements - **Minimum**: Java 11 - **Recommended**: Java 17 or newer ## 📋 Migration Notes ### Automatic Configuration Migration - Existing configurations will continue to work without changes - New features are disabled by default to maintain current behavior - Configuration files will be automatically updated with new options ### Breaking Changes - None - this update is fully backward compatible ## 🔍 Developer Notes ### New API Features - `ChunkDataCache.getAtomicCounter()` - High-performance block counting - `RecentlyBrokenBlocksTracker` - Track recently broken blocks with grace periods - Enhanced `ChunkOverloadEvent` with better context information ### Internal Changes - Refactored `StorageListener` for better performance and reliability - Added `ItemCleanerListener` for broken block tracking - Improved `PerformanceTracker` with smarter alert logic ## 🐛 Known Issues ### Resolved - ✅ TNT limit bypass exploit - ✅ Alert spam when no players online - ✅ Item cleaner removing freshly mined items - ✅ Race conditions in block placement validation ### Monitoring - Performance impact of new tracking systems (expected to be minimal) - Memory usage with large numbers of recent block breaks (automatic cleanup implemented) ## 🙏 Credits Thanks to the community for reporting these issues and providing valuable feedback that made this update possible. ## 📚 Documentation For detailed configuration and usage instructions, please refer to the main README.md file. --- **Download**: Available on GitHub Releases **Support**: Open an issue on GitHub for bug reports or feature requests **License**: GPL-3.0 *LagXpert v2.3 - Making Minecraft servers faster and more reliable, one optimization at a time.*
release

Major Features Added

2.2
19 июн. 2025 г.37Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# 📋 LagXpert Free - Changelog --- ## [2.2] - 2025-01-19 ### 🚀 Major Features Added - **Smart Mob Management System**: Automatically removes excess mobs while protecting important entities - Protects named mobs, tamed animals, equipped entities, and plugin-created mobs - Intelligent priority system (farm animals removed before valuable entities) - Performance-optimized gradual removal (max 10 mobs per chunk per tick) - Chunk processing cooldowns to prevent lag spikes - Comprehensive notifications with detailed statistics ### 🌐 Multi-Platform Support - **Platform Detection**: Automatically detects Folia, Paper, Spigot, or Bukkit - **Folia Compatibility**: Native support with RegionScheduler and AsyncScheduler - **Cross-Platform Scheduling**: Intelligent scheduler wrapper for optimal performance - **Backward Compatibility**: Seamless fallback to Bukkit scheduler when needed ### 🎮 Bedrock Edition Support - **Player Detection**: Automatic identification of Bedrock players via Geyser/Floodgate - **GUI Optimization**: Bedrock-specific inventory layouts and material handling - **Cross-Platform GUIs**: Separate templates for Java and Bedrock players - **Smart Fallbacks**: Chat-based alternatives when GUIs aren't compatible ### 🔧 Performance Enhancements - **Zero-Lag Design**: All new systems designed to improve performance, not hinder it - **Intelligent Caching**: Platform detection and player type caching for optimal performance - **Batch Processing**: Operations grouped to minimize server load - **Region-Based Processing**: Folia optimization for distributed chunk processing ### 📊 Enhanced Monitoring - **Advanced Statistics**: Detailed tracking of mob removals, protections, and performance - **Platform Reporting**: Comprehensive platform detection and capability reporting - **Migration Tracking**: Automatic configuration version tracking and migration status ### ⚙️ Configuration System Improvements - **Automatic Migration**: Seamless upgrade from v2.1.x with automatic backup creation - **New Configuration Sections**: Platform detection, Bedrock compatibility, smart mob management - **Enhanced Documentation**: Comprehensive inline documentation for all new features - **Backward Compatibility**: Preserves all existing settings during migration ### 🛡️ Entity Protection Enhancements - **Advanced Protection Logic**: Multiple layers of entity protection with priority systems - **Plugin Integration**: Detects and protects entities created by other plugins - **Metadata Awareness**: Respects custom entity metadata and flags - **Configuration Flexibility**: Granular control over protection rules ### 🎯 User Experience Improvements - **Intelligent Notifications**: Detailed feedback about optimization actions taken - **Cross-Platform Commands**: All commands work seamlessly across Java and Bedrock - **Enhanced Debugging**: Comprehensive logging and debugging options for troubleshooting - **Progressive Enhancement**: Features gracefully degrade based on available platform capabilities ### 🔄 API Enhancements - **New API Methods**: SmartMobManager integration for external plugins - **Platform Detection API**: Allows other plugins to detect server platform - **Bedrock Player API**: Utilities for detecting and handling Bedrock players - **Enhanced Events**: Additional context and information in existing events ### 📋 Migration & Compatibility - **Automatic Configuration Migration**: Seamless upgrade from any v2.1.x version - **Backup Creation**: Automatic backup of old configurations with timestamps - **Zero Downtime**: Migration occurs during plugin startup with no service interruption - **Rollback Support**: Easy restoration from automatically created backups ---
release

LagXpert Free 2.1.1

2.1.1
15 июн. 2025 г.39Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# LagXpert v2.1.1 - Bug Fix Update ## Bug Fixes - Fixed configuration warnings on startup - Eliminated unnecessary "Could not save X.yml because X.yml already exists" warnings that appeared during plugin initialization - Improved startup logging - Cleaner console output during plugin loading process ## Technical Details - Enhanced configuration file detection logic to prevent false warnings - Optimized default configuration saving process - No functional changes - all features work exactly the same ## ⚡ What's New This is a minor maintenance update focused on improving user experience by removing confusing warning messages that appeared on plugin startup. The warnings were harmless but caused unnecessary concern for server administrators. ## Compatibility - Minecraft: 1.16.5 - 1.21+ - Java: 11+ - Update Process: Simply replace the JAR file - no configuration changes needed Download LagXpert v2.1.1 and enjoy a cleaner startup experience!
release

Bug Fixes & Improvements

2.1
6 июн. 2025 г.58Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5bukkit, folia, paper, purpur, spigot
Скачать
Что нового
## **LagXpert v2.1 - Bug Fixes & Improvements** ### Critical Bug Fixes **Item Cleaner System:** - Fixed excluded items being deleted despite being in the exclusion list - Improved item type detection and comparison logic - Added automatic protection for enchanted items, named items, and items with lore - Better error handling to prevent crashes with corrupted items **Entity Cleanup System:** - Fixed named entities being removed incorrectly - Fixed tamed animals being deleted despite protection settings - Fixed leashed entities being removed when they shouldn't be - Improved detection of custom names, taming status, and leash connections - Better respect for all protection configuration options **Configuration System:** - Fixed configuration lists not loading properly from files - Improved validation to prevent invalid settings - Added automatic fallback values for missing or empty configurations - Better error messages when configuration files are missing **Improvements** - Enhanced debug logging for better troubleshooting - Improved performance with better error handling - More reliable detection of important entities and items - Better configuration validation on server startup **⚠️ Important Notes** - Your existing configurations will continue to work - Excluded items in itemcleaner.yml will now be properly respected - Protected entities in entitycleanup.yml will now be properly protected - Enable debug mode in config.yml to see detailed logs if needed This update focuses on fixing critical issues reported by users. No new features were added to ensure stability.
release

Major Update

2.0
5 июн. 2025 г.37Minecraft: 1.16.5, 1.17, 1.17.1, 1.18, 1.18.1, 1.18.2, 1.19, 1.19.1, 1.19.2, 1.19.3, 1.19.4, 1.20, 1.20.1, 1.20.2, 1.20.3, 1.20.4, 1.20.5, 1.20.6, 1.21, 1.21.1, 1.21.2, 1.21.3, 1.21.4, 1.21.5bukkit, folia, paper, purpur, spigot
Скачать
Что нового
# 🚀 LagXpert v2.0 - Major Update **Release Date:** June 2025 **Compatibility:** Minecraft 1.16.5+ (Spigot/Paper) --- ## 🌟 What's New in v2.0 LagXpert v2.0 is a **complete rewrite** that transforms your server's performance management. This isn't just an update - it's a revolution in how you handle server lag. ### 🎯 **Smart Performance Monitoring** - **Real-time TPS tracking** - Know exactly when your server starts lagging - **Memory usage monitoring** - Catch memory issues before they crash your server - **Automatic lag spike detection** - Get instant alerts when performance drops - **Performance history** - Track your server's health over time - **Daily and weekly reports** - Understand your server's performance patterns ### 🧠 **Intelligent Chunk Management** - **Smart chunk unloading** - Automatically removes inactive chunks to save memory - **Directional chunk preloading** - Loads chunks ahead of moving players for smoother gameplay - **Activity tracking** - Learns which areas are important to keep loaded - **Border optimization** - Special handling for world border chunks - **Performance safeguards** - Protects important blocks and redstone from accidental unloading ### 🎮 **Interactive GUI Configuration** - **No more YAML editing** - Configure everything through an easy-to-use in-game menu - **Real-time previews** - See changes before applying them - **Session management** - Safe configuration editing with timeout protection - **Permission-based access** - Control who can modify settings ### 🌍 **Per-World Settings** - **World-specific limits** - Different rules for Nether, End, and custom worlds - **Inheritance system** - Override only what you need, inherit the rest - **Dynamic configuration** - Create new world configs without server restarts - **Automatic detection** - New worlds get appropriate default settings ### ⚡ **Enhanced Performance Engine** - **Advanced caching system** - Dramatically faster chunk analysis - **Asynchronous processing** - Heavy operations won't freeze your server - **Circuit detection** - Automatically identifies and manages redstone clocks - **Smart entity cleanup** - Removes problematic entities without affecting gameplay ### 📊 **Professional Monitoring Tools** - **TPS Command** - Detailed performance information at your fingertips - **Memory tracking** - Monitor Java heap usage and garbage collection - **Chunk statistics** - See exactly how many chunks are loaded - **Lag spike analysis** - Identify patterns in server performance issues --- ## 🔧 Installation & Update Guide ### 📥 **Fresh Installation** 1. Download LagXpert v2.0 2. Place the `.jar` file in your `plugins/` folder 3. Restart your server 4. LagXpert will automatically create all configuration files 5. Use `/lagxpertgui` to configure settings through the GUI ### 📈 **Updating from v1.x** 1. **Stop your server** 2. **Backup your current LagXpert folder** (important!) 3. Replace the old `.jar` file with LagXpert v2.0 4. Start your server 5. LagXpert will automatically migrate your old settings 6. Your existing limits and configurations will be preserved 7. New features will use default settings **⚠️ Your server will NOT be affected during the update. All your current limits and settings will continue working.** --- ## 🎯 Why You Should Update ### 🚀 **Massive Performance Improvements** - **70% faster chunk scanning** - Operations that took seconds now take milliseconds - **Reduced memory usage** - Smart caching reduces RAM consumption by up to 15% - **Better server stability** - Advanced monitoring prevents crashes before they happen ### 🎮 **Better Player Experience** - **Smoother gameplay** - Intelligent chunk preloading eliminates lag spikes - **Faster world loading** - Players experience less waiting when exploring - **Consistent performance** - Automatic optimization keeps your server running smoothly ### 👨‍💼 **Easier Server Management** - **No more config file editing** - Everything can be done through the GUI - **Better monitoring** - Know exactly what's happening on your server - **Automated optimization** - Let LagXpert handle performance tuning for you - **Detailed insights** - Understand your server's performance like never before ### 🛡️ **Enterprise-Grade Features** - **Predictive alerts** - Get warned before problems become critical - **Historical analysis** - Track performance trends over weeks and months - **Professional reporting** - Generate performance reports for your team - **Scalable architecture** - Supports servers with 1000+ concurrent players --- ## 📋 New Commands | Command | Description | |---------|-------------| | `/lagxpertgui` | Open the interactive configuration interface | | `/tps` | View detailed server performance information | | `/tps detailed` | Advanced performance statistics | | `/tps memory` | Memory usage and garbage collection stats | | `/tps lagspikes` | Recent lag spike analysis | --- ## 🔑 New Permissions | Permission | Description | |------------|-------------| | `lagxpert.gui` | Access to the configuration GUI | | `lagxpert.tps` | View server performance information | | `lagxpert.monitoring.alerts` | Receive performance alerts | --- ## ⚙️ Configuration Highlights ### 🆕 **New Configuration Files** - `monitoring.yml` - TPS and performance tracking settings - `chunks.yml` - Smart chunk management configuration - `entitycleanup.yml` - Advanced entity cleanup options - `config/worlds/` - Per-world override configurations ### 🔄 **Enhanced Existing Files** - All existing configurations have been expanded with new options - Backward compatibility maintained - your current settings still work - New features use safe defaults --- ## 💡 Pro Tips for v2.0 1. **Start with GUI** - Use `/lagxpertgui` to familiarize yourself with new features 2. **Check TPS regularly** - Use `/tps` to monitor your server's health 3. **Customize per world** - Set different limits for Nether and End dimensions 4. **Monitor alerts** - Enable performance alerts to catch issues early 5. **Review reports** - Check daily performance summaries to optimize settings --- ## 🛠️ Technical Notes - **No breaking changes** - All existing functionality is preserved - **New dependencies** - None! Still only requires Spigot API - **Memory usage** - Initial memory usage may be slightly higher due to monitoring features - **CPU impact** - New async processing actually reduces CPU load - **Database** - No database required, all data stored in lightweight files --- ## 🐛 Known Issues - GUI sessions timeout after 5 minutes of inactivity (by design) - Some advanced chunk management features may need fine-tuning for very large servers - Performance monitoring generates more log entries (can be disabled) --- ## 🙏 Support & Feedback Found a bug? Have a suggestion? Need help? - **SpigotMC:** [LagXpert Resource Page](https://www.spigotmc.org/resources/lagxpert-free.124725/) - **Discord:** Join our community server - **Issues:** Report bugs through our issue tracker --- ## 📈 Coming Next LagXpert v2.0 sets the foundation for exciting future features: - Discord integration for alerts - Web-based dashboard - Machine learning lag prediction - Advanced analytics and reporting --- **Thank you for using LagXpert! Your server's performance journey just got a major upgrade.** 🎉