NoLag Ultimate 21.6.1

NoLag Ultimate is an open-source Minecraft server optimization and protection plugin that brings performance diagnostics, memory maintenance, entity management, and configurable safeguards into one toolkit.

Instead of relying solely on periodically removing dropped items, NoLag provides several independent systems for monitoring server activity and managing specific sources of server load. These include redstone activity, fluid-based lag machines, entity processing, inventory transfers, TNT explosions, Nether chunk traversal, memory pressure, and world-saving operations.

Its behavior is configurable, allowing server administrators to choose which protections to enable and how aggressively they should respond to performance pressure.

Performance Monitoring & Diagnostics

Understand your server's condition with in-game monitoring and diagnostic tools.

• TPS and MSPT monitoring: View server tick performance and identify periods of increased processing time.
• Memory statistics: Inspect Java heap usage, available heap capacity, and memory-pressure indicators.
• Server statistics: Review available entity counts, loaded chunks, memory usage, and configured view distance.
• Performance Impact Analyzer: Collect timing data across supported categories, including chunks, entities, redstone, hoppers, physics, fluids, TNT, cleanup, and memory.
• In-game dashboard: Access server diagnostics through a graphical interface.
• Plugin Lag Watcher: Sample main-thread activity to identify potential plugin-related performance problems and provide configurable administrator alerts.

The Plugin Lag Watcher uses sampling and estimates rather than providing exact execution-time measurements for every plugin. These tools are intended to help investigate performance issues; they do not guarantee a particular TPS or replace a complete profiler.

Redstone Lag-Machine Detection

Redstone mechanisms can generate substantial processing overhead when they repeatedly trigger updates or operate at excessive rates.

NoLag combines multiple redstone safeguards:

• Detection of repeated redstone transitions and clock-like activity.
• Per-block and per-chunk activity tracking.
• Pattern-based detection that considers surrounding activity.
• Selective suppression of suspicious redstone transitions.
• Configurable redstone update limits when server performance declines.

The goal is to identify unusually intensive patterns rather than indiscriminately disabling every redstone mechanism.

Compatibility note: Suppressed redstone updates can affect clocks, farms, and automated machinery. Test the protection with your actual builds and review the relevant configuration before deploying it on a production world.

Fluid Flood & Machine Protection

NoLag includes a dedicated Fluid Flood Protection module for detecting and responding to suspicious fluid-related activity.

Its detection logic considers signals such as:

• Dense or unusually rapid fluid propagation.
• Rapid placement of fluid source blocks.
• Repeated dispenser activity.
• Piston activity associated with moving machinery.
• Ice-related events and selected flying-machine patterns.
• Multiple signals that can indicate an intentional fluid-based lag mechanism.

Depending on the detected pattern and configuration, the module can cancel selected fluid events, neutralize suspicious fluid or ice activity, and remove selected machine components.

The system includes configurable thresholds, tracking windows, confidence requirements, cooldowns, and emergency throttling settings.

Important: The supplied configuration enables machine-component removal. This can alter or destroy parts of a legitimate redstone build if its behavior matches the configured detection rules. Review features.fluid-flood-protection in config.yml and test it on a staging server before using it on worlds containing complex redstone contraptions or flying machines.

Entity AI & Visibility Management

NoLag provides separate systems for controlling entity processing and per-player entity visibility.

Adaptive Entity AI

When server TPS falls below the configured recovery threshold, eligible living entities outside the activation range can have their AI temporarily disabled. The system processes a bounded number of entities per run and restores AI as conditions recover or entities become relevant to nearby players.

Players, bosses, villagers, tamed animals, leashed entities, and other protected categories are excluded from the AI-throttling process.

This feature changes mob behavior intentionally and is not equivalent to a general reduction in all entity ticking.

Per-Player Entity Visibility

The Entity Culling module uses viewing direction and distance to determine which selected entities should remain visible to an individual player.

This is a visibility-management feature, not a universal server-side entity-tick optimization. Its effect on overall performance depends on the server workload and the number and types of entities involved.

Mob Stacking & Dropped Item Management

Reduce the number of separate entities where stacking is appropriate.

• Mob Stacker: Combine eligible nearby mobs into configurable stacks.
• Configurable stacking: Control stack size, minimum group size, scan radius, and processing intervals.
• Mob separation: Separate stacked mobs through the supported player interaction and permission system.
• Item Stacker: Merge compatible nearby dropped items into larger stacks.
• Item Expiry: Track dropped items and remove eligible tracked items after a configurable lifetime.
• Protected items: Support protection for named items, according to the configured item-expiry rules.

The supplied configuration sets the dropped-item lifetime to 180 seconds and enables protection for named items.

These systems provide more control than a simple global item-removal timer. Their behavior should still be tuned to the server's economy, farms, custom items, and gameplay requirements.

RamFixer & Memory Maintenance

RamFixer monitors Java heap pressure and runs maintenance routines according to configurable thresholds.

Available mechanisms include:

• Configurable medium, high, and critical memory-pressure thresholds.
• Incremental processing with a bounded time budget.
• Checks for chunks that may be eligible for safe unloading.
• Player-distance and other chunk-safety checks.
• Cleanup of eligible dead or invalid dropped-item entities.
• Cache maintenance across selected NoLag modules.
• Manual memory sweeps with before-and-after measurements.
• Optional, cooldown-protected garbage-collection requests.

Under elevated memory pressure, RamFixer can perform increasingly intensive maintenance according to its settings. Certain operations are limited or handled differently on Folia.

Realistic expectations: Java heap usage is managed by the JVM and depends on the server's current workload. A maintenance sweep does not guarantee an immediate or permanent reduction in RAM usage. The reported measurements reflect observed before-and-after values.

Adaptive Chunk Optimization

NoLag includes an optional chunk-optimization controller for adjusting configured view and simulation distances in response to server conditions.

When enabled, its logic supports:

• Configurable minimum and maximum distance limits.
• TPS-based adjustment and recovery checks.
• Gradual distance changes and hysteresis to reduce rapid oscillation.
• Movement-sensitive distance adjustment.
• Incremental chunk-maintenance routines with safety checks.
• Tracking to avoid unnecessary repeated distance updates.

Disabled by default: The supplied chunk-optimizer.enabled setting is false. Review the distance limits and chunk settings before enabling this system. The optional controller can change how much of the world players see or simulate; the reviewed implementation also ties its chunk-cleaning task to this controller being enabled.

NoLag does not claim to make distant chunks load for free. Chunk loading, simulation, and network activity still depend on the underlying server and its configuration.

Nether Chunk-Traversal Protection

Fast travel can trigger frequent chunk transitions and increase chunk-streaming activity, particularly in the Nether.

The dedicated Nether protection module monitors player movement and traversal patterns. Depending on the configuration and detected behavior, it can:

• Track unusually rapid movement and repeated chunk transitions.
• Apply configurable violation thresholds and recovery periods.
• Reduce per-player chunk send distance under selected conditions.
• Apply movement or vehicle-velocity damping.
• Support permission-based bypasses for trusted players.

The module is intended to mitigate selected high-speed traversal patterns. It does not promise to prevent every form of chunk-related lag or automatically prohibit every Nether roof interaction.

Some of its controls operate independently: for example, blocking teleportation to the Nether roof is disabled in the supplied configuration.

TNT, Explosion & Physics Safeguards

NoLag includes additional controls for gameplay patterns that can produce a high volume of work.

TNT and explosions

• Limit primed TNT and explosive minecarts per chunk.
• Reduce selected TNT chain-reaction behavior.
• Configure explosion yield handling.
• Control fire caused by explosions.

The supplied configuration uses a limit of 25 primed explosive entities per chunk.

Low-TPS physics controls

When TPS falls below the configured threshold, selected physics updates can be suppressed for materials and blocks such as sand, gravel, concrete powder, anvils, pointed dripstone, and dragon eggs.

Hopper throttling

Hopper-related inventory transfers can be selectively cancelled under configured low-TPS conditions. Stronger pressure can result in more aggressive throttling.

These measures can change redstone builds, item transport, explosions, or other gameplay behavior. Review their settings if your server relies on automatic farms or complex machinery.

Additional World & Gameplay Features

NoLag also includes several configurable utilities:

• Armor Stand Limiter: Restrict the number of armor stands that can be placed in a chunk. The supplied limit is 15 per chunk.
• Command Security: Restrict configured commands associated with expensive operations or administrative actions, with configurable messages and permission-based bypasses.
• Low-TPS Elytra Protection: Apply configured Elytra restrictions when server performance falls below the chosen threshold.
• Fast Leaf Decay: Remove eligible non-persistent leaves near a broken log without waiting for the normal leaf-decay process.
• Void Rescue: Teleport eligible players who fall below the world boundary to their respawn location or the world spawn.
• Scheduled Memory Maintenance: Trim selected internal caches when the configured memory conditions warrant maintenance.

The default command-filter list includes entries such as /fill, /setblock, /clone, and selected administrative or plugin-related command names. Review the full list and exclusions before enabling the filter on a public server.

Staggered World Saving

The Autosave Optimizer can save worlds in a staggered sequence instead of attempting to save all worlds at the same time.

Its settings include a minimum TPS threshold for starting a save and an interval between world saves. The reviewed configuration enables this feature on non-Folia platforms and disables vanilla autosave while the custom schedule is active.

Review this setting carefully: skipped saves during low TPS can affect save timing, and custom save scheduling is not enabled by this implementation on Folia. Test the configuration and maintain world backups before deploying it to a production server.

Commands

The main command is /nolag, with /nl, /lag, and /antilag as aliases.

Administrative actions use the corresponding nolag.* permissions. Review plugin.yml for the permission definitions.

Compatibility & Configuration

The reviewed source package uses Java 21 and declares a dependency on Paper API 1.21.1. The plugin detects Paper, Purpur, Spigot/Bukkit-compatible software, and Folia, but feature availability and behavior can differ between platforms.

Folia has a platform-aware scheduler path, while operations that require unsafe global access or cross-region state are limited or disabled. Do not assume every feature behaves identically across all supported server software or Minecraft versions; test the exact build you plan to use.

Configuration file: plugins/NoLag/config.yml

Before deployment, review the settings for fluid-flood protection, machine-component removal, command filtering, low-TPS restrictions, dropped-item expiry, RamFixer, autosave, and chunk optimization. Back up important worlds and test substantial configuration changes on a staging server first.

Version 21.6.1 — Stability & Optimization

This release includes refinements to scheduler-task handling, Folia-aware execution paths, incremental maintenance routines, chunk-safety checks, and the restoration of configured world and player settings.

The extent of each feature's effect depends on platform, configuration, hardware, JVM settings, world characteristics, player activity, and installed plugins. NoLag is a collection of monitoring and protection tools—not a guarantee of a fixed TPS or a substitute for proper server profiling.

Open Source

NoLag Ultimate is released under the Mozilla Public License 2.0 (MPL-2.0).

• Modrinth: https://modrinth.com/plugin/nolag-ultimate
• Source code: https://github.com/VoidOaz/NoLag-Ultimate

Bug reports, compatibility feedback, code reviews, and contributions are welcome.