ВЕРСИИ (50)

### New: diagnostics mode `/vdt diagnose on` writes down what the plugin sees and decides, so a problem can be looked at afterwards instead of only while it happens. One file per day in `plugins/ViewDistanceTweaks/diagnostics`, one JSON line per entry, no player names. - A sample every `interval-seconds` (60): MSPT, TPS, tick variance, free heap, players, and per world the distances, loaded chunks, players, the highest client view distance, terrain generation and the density bonus. On Folia also the MSPT of every player's region. - Every distance change with the rule behind it, the settings at start and after every `/vdt reload`. - `extra-sample-above-mspt`: an extra sample whenever MSPT goes above this value, at most every 10 seconds, so a short lag spike between two samples is not missed. Off by default. - `/vdt diagnose note <text>` adds your own line with a timestamp, for example when players report lag. `/vdt diagnose status` shows today's file and how much was written. - Switches for samples and changes, a world filter, a daily size limit, old days packed as `.jsonl.gz` and deleted after `keep-days`. - Off by default. `/vdt diagnose on|off` lasts until the next restart, `diagnostics.enabled` records from startup. Send the folder along with a bug report. ### Changed - **Decrease reasons name the rule that caused them.** `/vdt history`, the console line and the diagnostics file used to say `decrease (mspt=11.9, mode=mixed)` even when MSPT had nothing to do with it. They now say what it was, for example `decrease: client view cap (highest client 12 + 1 headroom)` or `decrease: MSPT above 47.0 + chunk budget`. - **The client view distance cap no longer pulls the simulation distance down.** Because view distance may never be lower than simulation distance, one player with a low render distance used to slow down farms and redstone for everyone in that world. The cap now stops at the current simulation distance and only holds back increases above it. - **The highest client view distance is held for three minutes.** A player switching dimensions no longer makes a world jump down and back up. ### Config update Existing config files get the new `diagnostics` block added on the first start (config version 5), switched off. Nothing else needs to change. ### Tested Folia 1.21.11 with bots rendering 6 and 12 chunks: the cap lowered only the view distance, kept the simulation distance, held the higher value for three minutes after that bot left, and every change carried the right reason. Paper 26.3: config upgrade, all diagnostics options, notes, status, the world filter and the packing of old files. 247 automated tests.

### Fixed - **Folia: MSPT and TPS now come from the regions your players are in.** Folia has no single server tick, and its MSPT and TPS methods answer for whichever region the calling thread belongs to. The plugin runs its checks on Folia's global region, which never carries players, so it saw a server that was always fast and the MSPT thresholds practically never fired. Distances on Folia were only steered by the chunk budget, the chunk generation safeguard and the memory safeguard. Now every online player's region is asked for its own MSPT and TPS every 5 seconds, on that region's thread, and the slowest region counts for the server. `/vdt doctor` shows where the figure comes from. Folia still offers no per tick timing, so the variance check stays off there. On Paper, Purpur and Spigot the MSPT reading is unchanged. - `/vdt doctor` and the `analyze` and `doctor` lines of `/vdt help` printed raw key names (`doctor.header`, `help.doctor`, ...) instead of text since 2.13.0. A test now checks that every key in `messages.yml` is actually loaded. ### Tested - Folia 1.21.11 with 8 bots and a deliberately overloaded region: the plugin read the same MSPT as Folia's own `/tps` report and lowered the distances. AFK throttling and density scaling were checked in the same run. - Paper 26.3: clean start, `/vdt doctor`, `/vdt help` and `/vdt mspt` correct. No config changes.

### Changed - New defaults for how fast the plugin reacts. A benchmark on fresh terrain (players flying into land nobody had generated yet) showed the old defaults raising the view distance to 16 while single ticks took over a second, and taking about two minutes to back off. The cause: MSPT was averaged over a full minute, which hides a one-second freeze almost completely, and the chunk generation safeguard was off. - `ticks-per-check` 600 -> 200: worlds are checked every 10 seconds instead of 30. - `passed-checks-for-increase` 3 -> 9: growing stays exactly as fast as before (about +2 chunks every 90 seconds), only reacting to load got faster. - `collection-period` 1200 -> 200: MSPT is averaged over 10 seconds instead of a minute. - `chunk-generation-safeguard` is now on, trips at 8 newly generated chunks per second instead of 15, and caps view distance at 8 while it is tripped (`emergency-view-distance` -1 -> 8). Walking into new land stays below that; elytra and horse travel does not. - The `event-mode` profile's `passed-checks-for-increase` 20 -> 60, so it keeps the same pace. With these values, on fresh terrain the p99 tick time went from 242 / 406 ms to 58 / 48 ms and ticks over 100 ms from 485 / 733 to 107 / 114 (two runs each, same bot routes). On pre-generated terrain nothing got worse: the plugin still holds about 14.5 view distance at the stutter level of a fixed 12. ### Config update Existing config files are updated on the first start. A value is only changed if it still has the old default; anything you set yourself stays as it is, and a backup is kept as `config.yml.bak`. Each changed line gets a short note with its old value. If your `ticks-per-check` was still 600, every `passed-checks-for-increase` in the file (profiles included) is tripled with it, so the climbing pace you chose stays the same. The console lists every setting it changed.

### Added - `/vdt doctor`. One look at everything that commonly goes wrong, in a single list: platform and scheduler, whether the plugin is enabled, MSPT thresholds that leave no gap, worlds with a minimum above their maximum, worlds that are configured but not loaded, other plugins that keep overwriting a world's distances (with the likely culprits), the per-world MSPT state, free heap, PlaceholderAPI and whether an update is out. It reads only and changes nothing. Pasting its output into a bug report answers most of the first questions. Permission: the same as `/vdt status`. - `/vdt analyze` and `/vdt doctor` are listed in `/vdt` help. ### Changed - The readme and the project page now describe the client view distance cap and the conflict detection from the 2.11 and 2.12 releases, and list the placeholders only once. No config changes. messages.yml gains a `doctor` section; an existing file keeps working, the new lines fall back to the bundled English text.

### Cap view distance at what the clients actually render Nobody sees further than their own client draws. If the highest client setting in a world is 8, a server view distance of 16 loads, ticks and pays for rings of chunks that are never sent to anyone. The new `client-view-distance-cap` section caps a world's view distance at the largest value its players' clients report, plus a small headroom. It never goes below that world's `min-view-distance`, simulation distance follows so `view >= sim` still holds, and an empty world is left alone. A client that never reported a value counts as unknown rather than as a cap of zero. Off by default. It only pays on servers whose players run low settings, and changes nothing where everyone uses 16 or more. `/vdt status` shows the highest client value per world when it is on. ### A config upgrade that quietly did nothing Found while building the above, and it would have affected every future option: the upgrader keeps a hand-maintained list of the sections it knows. A section missing from that list was never added to an existing config, while the config version marker was raised anyway, after which the upgrader stayed silent about it for good. The option then ran on its code default and nobody could find it in their file. There is now a test comparing that list against the shipped config, so a new section cannot slip through again. ### Shorter comments Roughly 1700 lines of explanatory comment came out of the source. The reasoning behind each fix lives in the commit that made it; what stays in the code is the short note that keeps a line from being rewritten wrongly. No behaviour changed. ### Upgrading Replace the jar and restart. The new section is added to your existing `config.yml` automatically, switched off.

A follow-up to 2.11.6, from the same report. ### The warning now names the plugins that could be responsible 2.11.6 started saying when something else on the server overwrites view or simulation distance. Useful, but it left the obvious question open: which plugin? On the server this came from, answering that meant going through forty plugins by hand. There is no way to catch the writer in the act, since Bukkit has no event for it and the call is long gone by the time the next check notices. What can be answered is which plugins are even able to do it: a call to `setViewDistance` leaves the method name in the calling class, and Bukkit API names survive obfuscation. So the warning is now followed by a second line: ``` Plugins installed here that CAN write view or simulation distance: ClearLag. This lists what is capable of it, not what did it - a plugin whose feature is turned off still appears, and so does one that only changes it per player. Check their configs for a view-distance option before changing anything, and do not remove a plugin on the strength of this line. ``` The wording is deliberate. The scan proves capability, never guilt: a plugin with the feature switched off still matches, and `Player#setViewDistance` is spelled the same as the world method, so per-player plugins match without ever touching a world. It exists to turn forty plugins into two worth checking, not to pick one out. If nothing matches, it says so too, and points at server.properties and proxies instead. The scan reads the jars once per server start, on a background thread, and only after a conflict has actually been detected. Servers that never hit one never pay for it. ### Upgrading No config changes and no new keys. Replace the jar and restart.

One fix, from a live server report. ### The plugin now notices when another plugin overwrites it If something else on the server also writes view or simulation distance, the plugin never knew. Every cycle it read the foreign value as the current state, wrote its own over it, logged an honest change, and did the same thing again 30 seconds later. On the server this was reported from, that meant twenty worlds producing the same log line every 30 seconds, forever, and players reloading chunks on a timer because the value kept moving. Nothing in the log suggested the plugin was being overruled rather than simply doing its job, so finding the cause took hours. It turned out to be a lag-management plugin with its own view distance feature. The plugin now remembers what it last set. If a world comes back changed three checks in a row, it says so once: ``` 'world_nether': view distance set to 12 but found at 20 on the next check, 3 times in a row. Something else on this server writes these values too ... Leaving this world alone. Check your other plugins for a view-distance setting, then /vdt reload to resume managing it. ``` Then it stops managing that world, which ends both the log spam and the chunk reloading. `/vdt status` marks the world so the state is visible after the warning has scrolled away. A reload, or setting that world by hand, resumes management. Three checks rather than one on purpose: a single mismatch is an admin running a command or a world reloading, not a second plugin. ### Upgrading No config changes and no new keys. Replace the jar and restart.

One fix, found while testing against Paper 26.3. ### An ampersand that is not a colour code keeps its ampersand Colour codes are written with `&`, and every `&` in a message was turned into the section sign the client renders colours with, whether or not a colour code followed it. An ampersand written as a word therefore ate itself and left behind a character the client cannot resolve. The built-in help showed it: `/vdt mspt` was described as "Show MSPT, TPS § variance". The same happened to any `&` you wrote in your own `messages.yml` or in `announce-format`. Nothing ever reported this, because there is nothing to report. A stray section sign is not an error at runtime, it simply renders as a stray character. Only `&` directly followed by a real code is translated now, which is what Bukkit itself does. One limit is unchanged and cannot be removed: a code letter is a code letter, so `&d` is light purple whether or not you meant to write "R&D". ### Paper 26.3 Tested against build 5 under Java 25. Clean start, no deprecation warnings, every command behaving correctly, and the distance engine climbing 10 to 12 across three worlds in three confirmations, exactly as the defaults intend. ### Upgrading No config changes and no new keys. Replace the jar and restart.

One fix, found by reading the code rather than from a report. ### An operator pause on a pre-generation run undid itself `/vdt pregen pause` and `/vdt pregen stop` both worked, reported success, and were then quietly reversed. The per-tick driver tracks two things: whether a run is paused, and whether the plugin paused it itself. Anything that blocks generation - a player logging in, an MSPT spike, a dip in free heap - wrote both. So the first blocker to come along relabelled an operator's pause as the plugin's own, and the release that follows lifted it as soon as that blocker cleared. The run carried on generating terrain nobody had asked it to resume, and `/vdt pregen status` showed the blocker as the reason instead of the command that actually paused it. The failure path is the worse half. When a chunk request is refused, the run stops rather than cancels, specifically so the request is not retried in a loop and the progress survives until someone looks at the cause. That containment ran through the same operator pause, so it did not hold: the run came back on its own and asked for the same failing chunk again. An operator pause is now settled before any blocker is looked at. ### Upgrading No config changes and no new keys. Replace the jar and restart.

Four fixes from an error-analysis pass over the whole plugin. Nothing here was reported from outside; all four came out of reading the code, and each one is covered by a test that was checked against the unfixed build first. ### The memory safeguard could go blind after a clock jump 2.11.1 rewrote this to judge free heap by the lowest usage seen in the last minute, which is the right measurement. It timed that window with `System.currentTimeMillis()`, which is a wall clock and can step in both directions: an NTP correction, a resumed VM, a host clock sync. A backwards step is the dangerous one. The window stops accepting new samples and keeps only the branch that revises the current reading downwards, so it freezes holding an old trough that can fall but never rise. For the length of the jump the plugin reports free memory the server no longer has, and distance increases are allowed into a filling heap. Every reading in there is a duration, never a date, so it now uses `System.nanoTime()`, which is monotonic within a JVM. The condition cannot arise. ### A release was invisible to the pre-release that shared its number Version comparison read the numbers and stopped, so `2.11.0-RELEASE` and `2.11.0-ALPHA` came out equal. Anyone running an alpha or a beta was never told the finished version existed, and auto-update never staged it. Ties now break the way semantic versioning breaks them: a pre-release ranks below the release with the same numbers. Anything unrecognised counts as a release, so this can only ever withhold an update, never invent one. ### Two quieter ones `chunk-generation-safeguard` kept a counter per world and nothing removed it when a world was unloaded. Servers that create and discard worlds at runtime, minigame arenas and per-player plots, accumulated one entry per world for the lifetime of the process. On Folia, a refused scheduler dispatch was logged and otherwise swallowed. The complexity sampler decides who publishes its result by counting outstanding work, so a task that never ran left it waiting forever and every world kept the multiplier it already had, which is `1.00x`. With `use-complexity-weighting` on, the feature would have done nothing at all, without a line anywhere to say so. ### Upgrading No config changes and no new keys. Replace the jar and restart.

First stable since 2.10.8. If you skipped the 2.11.0 alpha and the 2.11.1 beta, everything from both is in here. ### The memory safeguard was reading the wrong number **If your start script sets `-Xms` equal to `-Xmx`, this one affects you.** That is what Aikar's flags and essentially every hosting panel recommend, so it is most servers. The free-heap figure was unused space in the current heap plus whatever the JVM was still allowed to grow by. Commit the heap in full at startup and that second term is zero forever, leaving raw occupancy. Occupancy counts garbage that has not been collected yet, and every modern collector deliberately lets the heap fill before reclaiming it. So the number described where the GC cycle happened to be, not how much memory your server needed. That alone would be an occasional wrong reading. What made it permanent is that an increase needs `passed-checks-for-increase` clean checks in a row, and any veto resets that counter, so a minority of false readings is enough to pin a server at its minimum distance indefinitely. It now measures the lowest heap usage seen in the last minute. Right after a collection, usage is the live set, so that figure is a real measurement of what the server needs. On a 1GB ZGC heap the old build logged five vetoes, made zero distance changes in six minutes and finished where it started. The new build logged none, made eleven, and climbed from simulation distance 4 to 12. On a heap with room to spare, where the old reading happened to be right, both behave identically. ZGC is affected from the start. G1 with Aikar's flags holds out longer, but goes the same way once live data passes roughly half the heap. **If you lowered `min-free-percent` to work around this, you can put it back to 15.** ### Per-world MSPT The server reports one MSPT figure for everything, so a single struggling world used to drag every other world's distance down with it. Turn on `per-world-mspt` and the tick is split between worlds, each judged by the share it actually causes. Off by default. ### `/vdt analyze` Reads the server's own change history and MSPT-versus-chunk-count samples, then suggests config values that fit what this specific server has shown. It only suggests, nothing is applied. ### Ping throttling The same idea as AFK throttling, triggered by a bad connection instead of an idle player. A player whose ping stays above the threshold for a few checks running gets reduced personal distances. A single spike does not trigger it and recovery is immediate. If a player is both AFK and on a bad connection the more restrictive value applies, and an explicit `viewdistancetweaks.fixed.<n>` permission still beats both. Off by default. ### Pre-generation: world border and scheduling Idle pre-generation clamps its radius to the world border by default, so a radius entered too large costs a log line instead of generating chunks nobody can reach. `/vdt pregen schedule <world> <radius> <HH:mm>` starts a run at a clock time rather than waiting for an empty server; every existing safety net still applies once it is running. ### Faster climb defaults `passed-checks-for-increase` 10 to 3, `max-increase-step` 1 to 2, `max-decrease-step` 1 to 4. Climbing from 4 to 16 now takes about nine minutes of uninterrupted good health instead of an hour. **These apply to new installs only.** An existing config.yml already contains those keys, so your values are kept. ### Upgrading from 2.10.8 Close to a pure bugfix. The only block added to your config.yml is `ping-throttling`, and it ships disabled. Every other feature above is off by default as well, and your tuned values are preserved. `/vdt status` now labels the heap figure `live`, because that is what it measures.

This is a BETA. `accepted-release-types` defaults to `release`, so this build is not offered to existing installations unless an admin opts in by hand. It contains one fix that matters to almost every server, and it needs confirmation on a real one before it goes out as a stable. **If your start script sets `-Xms` equal to `-Xmx`, this fix is for you.** That includes Aikar's flags and the default of essentially every hosting panel. ### The memory safeguard was reading the wrong number Reported by a user running ZGC with a fully committed heap: the safeguard blocked every distance increase, permanently, on a server with plenty of memory left. The free-heap figure was unused space in the current heap plus whatever the JVM was still allowed to grow by. Commit the heap in full at startup and that second term is zero forever, leaving raw occupancy. Raw occupancy counts garbage that has not been collected yet, and every modern collector deliberately lets the heap fill before reclaiming it. So the number described where the GC cycle happened to be, not how much memory the server actually needed. What made it total rather than occasional is that an increase needs `passed-checks-for-increase` consecutive clean checks, and any veto resets that counter. A minority of false readings is enough to pin a server at its minimum distance indefinitely. It now measures the lowest heap usage seen in the last minute. Right after a collection, usage is the live set, so that figure is a real measurement of what the server needs rather than a snapshot of the GC cycle. Measured on a 1GB ZGC heap: the old build logged five vetoes, made zero distance changes in six minutes and finished where it started. The new build logged none, made eleven, and climbed from simulation distance 4 to 12. On a heap with room to spare, where the old reading happened to be right, both behave identically. ZGC is hit hardest and from the start. Aikar's G1 flags hold out longer, because they begin marking early, but they go the same way once live data passes roughly half the heap. **If you lowered `min-free-percent` to work around this, you can put it back to 15.** ### `/vdt status` says what it means The free-heap line used to print a placeholder 100% until the first check ran, up to `start-delay` after every boot and reload, while showing the real figure in megabytes beside it on the same line. It now reports a measurement from the first second. The megabyte figure is labelled `live`, because that is what it is: heap held by live data, not by uncollected garbage. ### Why 2.11.1 and not 2.11.0 2.11.0 only ever went out as an alpha. The update checker compares the leading numeric part and ignores the suffix by design, so a 2.11.0 release would have compared equal to the 2.11.0 alpha, and every alpha install would have been told it was up to date forever. Going straight to 2.11.1 avoids that. Everything from 2.11.0-ALPHA is included: per-world MSPT, `/vdt analyze`, ping throttling, pre-generation border clamping and scheduling, and the faster climb defaults.

This is an ALPHA. It sits in the alpha channel on purpose: `accepted-release-types` defaults to `release`, so this build will not be offered to existing installations unless an admin opts in by hand. Try it on a test server first. ### Per-world MSPT The server reports one MSPT figure for everything, so a single struggling world used to drag every other world's distance down with it, including worlds that were not the problem. Turn on `per-world-mspt` and the tick is split between worlds, each judged by the share it actually causes. Off by default; the wiki has the details on what it changes and what it does not. ### `/vdt analyze` Reads the server's own change history and MSPT-versus-chunk-count samples, then suggests config values that fit what this specific server has actually shown, instead of guessing from a preset. It only suggests. Nothing it finds is applied automatically. ### Faster climb defaults The proactive engine used to need ten confirmed checks and moved one chunk at a time, which meant roughly an hour to climb from 4 to 16 chunks even on a server with headroom to spare. Defaults are now three checks and two chunks per step: ninety seconds per +2, so that same climb takes about nine minutes on a healthy server instead of one hour. `ticks-per-check` is unchanged: that number is about measurement quality, not reaction speed. ### Ping throttling The same idea as the existing AFK throttling, triggered by a bad connection instead of an idle player. A player whose ping stays above the threshold for a few checks in a row gets reduced personal view and simulation distances, freeing that budget for players whose connection can actually use it. A single lag spike does not trigger it, and recovery is immediate once the connection improves. If a player is both AFK and on a bad connection, the more restrictive of the two distances applies. An explicit `viewdistancetweaks.fixed.<n>` permission still wins over both throttles, same as before. ### Pre-generation: world border and scheduling Idle pre-generation now clamps its radius to the world border by default, so a radius entered too large costs a log line instead of generating chunks nobody inside the border can ever reach. Turn `respect-world-border` off if the plan is to pre-generate now and widen the border later. `/vdt pregen schedule <world> <radius> <HH:mm>` starts a run at a fixed time of day instead of only when the server empties out, for servers where "empty" rarely happens. The usual safety nets (MSPT, free memory, players online) still apply once the run is going; only the start condition changes. ### Status Ping throttling and the pre-generation changes above are new in this alpha and have not yet been run on a live server the way the rest of 2.11.0 has: per-world MSPT and the faster climb defaults were verified on Paper, Purpur and Folia under real player load before this release. Everything in this build passes the full test suite, including three runs with the test order randomized.

A follow-up to 2.10.7. Two of the three fixes here repair code that shipped yesterday, in the config upgrader that 2.10.7 rewrote — both found by testing that rewrite against awkward files rather than by reading it again. If your `config.yml` was correctly topped up by 2.10.7, nothing here changes for you. ### The config upgrader did nothing at all on a file with Windows line endings Java counts a carriage return as a line terminator, so the pattern matching each line left it unconsumed and failed on every single line of a CRLF file. The upgrader then found no blocks to look inside, added nothing, and reported nothing — an outcome indistinguishable from having had nothing to do. Any `config.yml` last saved by a Windows editor was silently skipped by 2.10.7's whole reason for existing. The file is now read regardless of its line endings, and keeps them when it is written back. ### A comment after a block's name made that block invisible to the upgrader A block written as a value — `some-option: 4` — owns no child options, and adding some would contradict the value already there, so those are deliberately left alone. A trailing comment looked exactly the same to that check: `proactive-mode-settings: # my note` was read as holding a value, and the entire block was skipped. That is precisely backwards. A file somebody has annotated by hand is a file somebody has tuned, which is the one most worth topping up carefully. ### Chunk complexity weights had no built-in default, so the feature could run and do nothing Every option in this plugin falls back to its documented default when your file does not mention it. `complexity-weights` was the single exception: with the section absent the list of per-block surcharges stayed empty, so every chunk weighed the same, every world's multiplier came out at exactly 1.0, and `use-complexity-weighting` ran without changing anything — while `/vdt status --weight` reported a tidy `1.00x` for every world. Any `config.yml` written before that block existed was in that state, which is every config not yet topped up by 2.10.7. Turning the feature on did nothing and said nothing. The thirteen shipped weights are now built in as well, so a missing section means the documented default like everywhere else. A section you have deliberately emptied still stays empty — that is an answer, not an omission — and if the feature is on with no weights at all, the log now says so instead of leaving you to wonder why nothing moved. ### Under the hood The shipped `config.yml` and the built-in fallbacks are now compared against each other in the test suite, option by option. They are meant to be identical — otherwise a fresh install and an upgraded one quietly behave differently, depending only on when the server was first set up — and that is now checked rather than assumed. It is what turned up the complexity-weights gap above.

Six defects found by reading the code, plus one the fixes themselves would have introduced. Nothing here was reported by anyone, which is rather the point: every one of them is a case where the plugin did something other than what it said, quietly. ### The config upgrader could not add an option to a block your file already had 2.8.3 taught the plugin to top up an old `config.yml` instead of telling you to delete it. It worked one level deep: whole top-level blocks were appended, and anything added *inside* a block your file already declares was invisible to it. Measured against a real 2.6 config, that left **17 options** behind — the entire chunk-complexity feature, which lives under `proactive-mode-settings`. Ten blocks were appended, the version marker was set to current, and the log said nothing about the seventeen it had not added. Because the marker was now current, the version check returned early on every later start too, so nothing ever mentioned it again. Absent would have been bad enough. What made it worse: `use-complexity-weighting` reads `false` when the key is missing, so anyone who found the option in the documentation and typed it in by hand got a feature that does nothing at all — `complexity-weights` was missing as well, so every chunk weighed exactly 1.0, every world's multiplier came out 1.0, and `/vdt status --weight` reported `1.00x` across the board with no explanation. Missing options are now merged into the block that owns them, carrying their comments, at whatever indentation your file already uses, and each one is named in the log. Your own values and comments are untouched, a `config.yml.bak` is still taken first, and running the upgrade twice changes nothing the second time. ### Updates needed two restarts, and a long-running server never saw them at all The update check ran exactly once, when the plugin enabled. A downloaded jar is staged in `plugins/update/` and installed by the *next* restart — so every update cost two restarts: one to notice and stage it, one to apply it. And a server that stays up for weeks never noticed anything, because its single check happened before the release existed. There is now a re-check every six hours. The jar is already waiting whenever the server does restart, so one restart is enough. `update-notify` still decides whether any of this runs, and switching it off takes effect on the next `/vdt reload` rather than at the next restart. ### The scheduler could only cancel its most recent repeating task Found while adding the re-check above, which is the first thing this plugin ever needed a second repeating task for. The adapter kept a single task handle, so registering a second one overwrote the first, and shutdown then cancelled only the newer of the two — leaving the engine's per-tick driver running against a plugin that had just been disabled. That would have bitten anyone reloading with a plugin manager rather than restarting. ### /papi info credited the wrong author The PlaceholderAPI expansion reported `EmpireBlocks` — the plugin's package name, not a person — while `plugin.yml` names LucasTHCR. Both now come from the same place, and the test suite compares them. ### Two messages said different things depending on where you read them Every message exists twice: as a built-in default and in `messages.yml`. The file wins at runtime, so a line that fell behind there is what servers actually show. `help.update` still advertised `/vdt update` long after `/vdt update download` existed, so the download argument was missing from the help output on every install. And `status.fixed.disabled` said "Both per-player override features are disabled" after AFK throttling had been added to the condition it describes — three features, two named. The two copies are compared in the test suite now, text and all, not just checked for having the same keys. ### Smaller `Messages.get()` carried a comment promising it would render what it could rather than throw inside a command handler, and then threw. No call site passes a mismatched replacement list today, which is exactly why the contradiction could sit there unnoticed; the code now does what the comment always claimed.

Six defects, all found by reading the code rather than from a report. Every one of them is a case where the plugin quietly did something other than what it said. ### Pre-generation could charge one run's chunks to the next one, on Folia A chunk request is asynchronous, so requests are still outstanding when a run is cancelled or finishes. The token that identifies which run a callback belongs to was read inside the task that had already been handed to the chunk's region, instead of before handing it over. On Paper that work runs inline, so the two are the same instant and the guard held. On Folia there is a real gap, and a run that ended inside it left the task reading the token of the run that came *next*. Those late callbacks then decremented the new run's in-flight count past zero — which widens its batch budget — counted chunks it had not built, and released positions from its outstanding set. That set is what the saved resume point is derived from, so the new run could skip ground nobody had generated, and a restart would not notice. The probe path had always captured the token at dispatch; the generation path does now too. This only ever affected Folia. If you are on Paper, nothing here changes for you. ### /vdt status --fixed reported "disabled" while it was throttling players The command was gated on `per-player-fixed-view-distance` and `per-player-fixed-simulation-distance` alone. AFK throttling sets its distances through exactly the same per-player machinery, so a server running only `afk-player-throttling` had players actively overridden while the one command whose job is to show that answered "this feature is disabled" and listed nothing at all. The rows were already written for it — each entry records whether it came from a permission or from the throttle, and the output has a line for both — only the gate never let anyone reach them. This is the same shape as the sweep bug fixed in 2.7.1: a feature gated on an unrelated flag. ### /vdt pregen pause did nothing to an auto-paused run, and said it had worked `pause()` returned early whenever the run was paused at all. That also covers the automatic pause the engine sets for players being online, MSPT over the limit, or free heap under the floor. So typing the command during any of those changed nothing, the reply still said "paused", and the moment the blocker cleared the engine lifted its own pause and the run carried straight on. An operator pause is now what it claims to be: it takes over an automatic one, and only a pause somebody already set by hand is left alone. `/vdt pregen stop` never had this problem. ### Idle pre-generation rebuilt the same area forever When an automatic run finished, the progress file was deleted and nothing was left on record saying the work was done. The next pass over an empty server therefore started the whole thing again on the same spawn centre and the same radius, and kept doing it for as long as nobody logged in. Every lap re-probes the entire area, and every probe pulls its chunk into memory — 251,001 of them at the default radius of 250. Nothing reported it, because each individual lap looked like an ordinary run. A completed automatic run is now recorded in `pregen-done.json` next to `config.yml`, and the trigger checks it against the area the config is currently asking for. Raising `idle-pregeneration.radius`, or pointing the feature at a different world, is new work and still runs; deleting the file starts the old area over. Manual `/vdt pregen start` runs are not recorded and are never blocked by it. ### Smaller things The chunk-complexity weigher keeps two maps keyed by world name. `forgetWorld()` cleared the engine's own six when a world unloaded but not those, so a server that creates and discards worlds at runtime — minigame arenas, per-player plots — kept an entry per world for the lifetime of the process. Predictive pre-loading drops its stored player positions when the MSPT or memory gate holds it back. Speed is measured as the distance since the last sample divided by one tick interval, so keeping the samples across a pause meant the first cycle afterwards charged the entire pause against a single interval: somebody who had walked off and stopped read as flying, along a path they had already finished. Startup grace measures its end from the current tick instead of from tick zero. That was only correct for the one caller there is today, and silently wrong for any other.

### A mistyped profile name silently dropped the profile you were running `/vdt profile <name>` tore the current overlay down before it looked the name up. Type `evnt-mode` instead of `event-mode` and the command answers "unknown profile" — but by then every value `event-mode` had set was already back to what `config.yml` says, including its `max-view-distance-cap`. Nothing said so. `activeProfile` still named the profile, so `/vdt status` went on reporting `event-mode` as in effect for the rest of the session, and only a `/vdt reload` put the real values back. The name is checked first now. A switch that is rejected leaves the running profile exactly as it was. ### The log line and the chat announcement lied about excluded dimensions A world with `exclude-simulation-distance: true` never has its simulation distance touched — the setter is skipped, which is the point. But the console line and the `announce-changes-in-chat` message were built from the numbers the engine had *asked* for, not the ones the world ended up holding. So a world sitting at simulation distance 12 was announced as "Sim: 12→6" while nothing had moved, and `{newSim}` in a custom `announce-format` carried the same wrong figure. `/vdt history` reads the same event and always recorded the applied value, so the two contradicted each other on exactly the servers that exclude a dimension. Both now report what the world actually holds. ### Emergency relief could not engage while the memory safeguard was active `emergency-relief` is the last thing `checkWorld()` does, and the increase veto above it returned outright. In `proactive` mode a world pinned at its minimum still computes a target above it, because the chunk budget says it could afford more — so the cycle counts as an increase, and the memory safeguard refuses it and returns. That is the exact situation relief exists for: at the floor, still over the threshold, nothing left to give back. It was the one path that could never reach it, and on a server with a tight heap it is the path taken every single cycle. Lifting relief already had its own route out for the same reason; engaging now has one too. ### Smaller things The version in `plugin.yml` is filled in from the build rather than written twice, so the number the update checker compares can no longer fall behind the jar it is in. Three new tests cover the cases above. All 61 pass, and each of the new ones fails against 2.10.4.

### Complexity weighting was doing nothing on Paper `use-complexity-weighting` measured every sample correctly and then threw the result away again. The sampling pass published from whichever sample finished last, and wrote a neutral 1.0 afterwards if none were left outstanding — which on Paper is always, because that work runs inline. Every world came out at 1.0 on every cycle, so the option had no effect at all on anything that is not Folia. It has been that way since 2.10.3. If you have it switched on, this release is the one where it starts working. Worlds full of redstone will now genuinely get a smaller chunk budget than worlds full of water, which is what the setting always claimed to do. The sample cap had the same root cause and never tripped either, so a world with more players than `complexity-sample-chunks` was oversampling. ### /vdt status told you nothing was throttled while it was throttling The player snapshot that `/vdt status` and `/vdt status --fixed` read was only refreshed by the distance engine's own cycle, while AFK throttling deliberately runs before that cycle starts. Throughout `start-delay`, during the five minutes of startup grace, and for as long as the plugin was disabled, the throttle was changing player distances while status reported "AFK players throttled: 0" and `--fixed` listed nothing at all. ### Pre-generation could skip chunks across a restart Progress was the probe frontier minus the number of chunks still outstanding. That only points at the right place if the unfinished chunks are the most recently probed ones, and they are not — probes come back out of order. A chunk left waiting at position 5 with the frontier at 100 saved a resume point of 99, and nothing ever built it. Progress now follows the lowest position that is genuinely unfinished, and no longer counts a chunk as done while it is still being generated. ### Smaller - A per-player fixed distance that happened to match its world's current distance was hidden from `/vdt status --fixed`. The reason behind a value is recorded now instead of guessed from the number. - The pre-loader takes each player's share of `max-chunks-per-cycle` before dispatching rather than inside the task, so on Folia forty players can no longer submit far more chunk requests than the cap allows. - The "already existed" counter is atomic, like the generated counter beside it — both are written from asynchronous chunk callbacks. - A stale probe callback no longer decrements a counter belonging to a run that already ended. - The daylight-cycle gamerule is resolved once at load instead of through a constant the Paper API has marked for removal, and emergency relief now names only the measures it actually took rather than always claiming both.

### Folia works Tested against a real Folia server for the first time, and two features were freezing it outright. `world.isChunkGenerated()` blocks inside CraftWorld on a future. On Folia that parks the global region thread on a result only that same thread could have produced, so the server stops ticking: the watchdog reported the global region gone after five seconds and it never came back. Idle pre-generation ran into it on its own the moment the last player logged off, because `start-when-empty` is on by default. Predictive pre-loading called the same method for any fast-moving player. Both now ask through `getChunkAtAsync(x, z, false)`, which answers the same question — the chunk if it exists, nothing if it would have to be generated — without holding up a thread and without generating anything. Chunk work is routed to the region that owns the chunk. On Paper every one of these paths runs inline exactly as before. Player state is read from the thread that owns it. Density scaling and complexity weighting read every player's position from the check cycle, and a world's players can sit in as many regions as there are players, so there was no thread from which those loops could be correct. They now work from positions each region reports for its own players. The per-player distance sweep decided its value on one thread and applied it on another; the whole evaluation moved. ### Pre-generation progress is honest again Probing ahead is bounded now. A run no longer reports 100% while thousands of chunks are still queued behind it, and the saved position follows the work that is finished rather than how far ahead the search has looked — a restart at that point used to drop everything still in the queue. ### Measured on Folia 1.21.11 Distances regulate, pre-generation runs and resumes, MSPT reads real values, and no watchdog incident occurs with every subsystem switched on.

### /vdt simulate now sees the same vetoes the engine applies The memory safeguard and the chunk-generation lock both refuse a distance increase inside the check cycle, but neither existed in the preview `/vdt simulate` builds. On a server sitting under `memory-safeguard.min-free-percent`, the preview therefore announced an increase that the engine went on to reject — every cycle, with nothing to say why. Both now go through one shared method, so the reason the preview prints is the condition the engine acted on. ### /vdt mspt has a permission of its own It was the only subcommand falling through to the base `/vdt` node, while `status`, `history` and `simulate` each required one. It reads the same figures as `/vdt status` and now shares that node, so no existing grant changes meaning. ### Smaller - Removed a duplicate `update.ahead` key from `messages.yml`. - `plugin.yml` now says that the reload permission also covers `/vdt update`.

## ViewDistanceTweaks v2.10.1 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Four fixes from a pass over the parts of the plugin the earlier reviews never reached. Nothing here changes how distances are chosen — these are all about a state that could not be left, a measurement that rested on an assumption, and two features that quietly did not work. ### Fixed - **Emergency relief could stay engaged indefinitely.** Relief clears a world's weather and freezes its clock, so what matters most about it is that it ends. The only path back sat at the end of the per-world check behind six early returns, and two of them stay reachable while relief is active. A world that recovered its tick time while free heap was still low hit the memory-safeguard return every cycle and never reached the check — weather off, clock frozen, for as long as memory was tight. A temporary override did the same thing permanently, because that return is the first thing the check does. Lifting no longer depends on any of it. - **The MSPT collection window rested on an assumption the API does not make.** It read `tickTimes[length - 1]` as the tick that had just finished. Paper's contract for that method is *"a sample of the servers last tick times"* — nothing is said about order. A ring buffer written modulo its length, which is the ordinary way to keep the last N of anything, would leave the same reading at that index for a hundred ticks at a stretch, and the window would have recorded it a hundred times over. It now averages the whole sample, which needs no assumption and is right either way. - **Two downloads could overwrite each other.** The auto-updater is reachable from the startup check and from `/vdt update download`, both asynchronous, and both wrote the same partial file. The hash mismatch that followed was reported as *"corrupted or tampered with"* — which an admin reads as an attack rather than as the plugin racing itself. A second download is now refused cleanly. The partial file is also removed after any failure rather than only on that one branch, and a download URL that is not HTTPS is refused. - **The EssentialsX AFK hook depended on load order.** It was resolved once during startup and never again, and EssentialsX was never declared as a soft dependency — so whether it was found at all came down to which plugin Bukkit happened to enable first. Switching `afk-use-essentials` on and running `/vdt reload` did nothing until the next restart, with no line to say so. It is declared now, and re-resolved on every reload. ### Also - The config shipped with the plugin now uses the same plain-ASCII punctuation as the project page, and the bStats link in the source names the registered project. ### Under the hood 43 tests. Each fix was checked against the previous code first — a test that passes before and after proves nothing. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.10.0 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. The first stable release since 2.8.3, and the one that finally **upgrades your config file instead of complaining about it**. It carries everything the 2.9 betas built and the fifteen bugs they turned up — including one that has been in the release line since 2.4. ### Your config.yml is topped up, not replaced Bukkit writes the bundled config only when the file is missing, so a server that had ever started kept its original copy forever. Every option added since was simply absent, the feature behind it ran quietly on a code default, and the only advice the plugin could give was "rename the file and restart" — which costs you every value you had tuned. The version marker was never written back either, so the warning came back on every start and every reload with nothing you could do to satisfy it short of editing YAML by hand. Missing blocks are now appended from the bundled file **with their comments intact**, and the marker moves up so the warning stops. Nothing existing is rewritten — YAML does not care what order top-level keys appear in, so appending cannot change the meaning of what is already there — and a copy is kept as `config.yml.bak` before the first write. Run against a real 2.8.2 config with hand edits, the only line that changed was `version: 1` becoming `version: 2`. Your values, your comments, and keys this plugin has never heard of all survive. ### New since 2.8.3 - **Idle pre-generation.** Builds terrain ahead of time, so players never wait for it. Runs when the last player logs off, or on demand via `/vdt pregen`. It throttles against the same rolling MSPT average the distance engine uses, **stops** rather than slows when free heap runs low, and writes progress to disk so a crash or a nightly reboot resumes where it left off. Off by default. - **Predictive pre-loading.** Loads chunks along the path of a fast-moving player, so arriving somewhere does not stall the tick. It makes chunks ready *server-side* — nobody sees further, you just stop feeling the hitch. Off by default. - **`adjustment-mode: off`.** Never touches view or simulation distance at all, for servers that want only the pre-generation and pre-loading subsystems. Those run independently of the distance engine. - **A readable Operating System chart on bStats**, because the built-in one drills down on the raw Linux kernel string and scatters 90% of servers across ~94 slices. ### Fixed since 2.8.3 - **An out-of-range distance stopped the engine.** `/vdt viewdistance 53` was handed straight to a setter that accepts only 2 to 32 and threw. Worse, the override was stored *before* it was applied, so the next check re-applied it and threw again — taking override expiry, per-player overrides and every remaining world check with it, on every tick, until `/vdt reload`. Present in the release line since 2.4. - **Per-world state was never cleaned up.** Check counters, cluster bonuses and pending reverts are keyed by world name and nothing removed them, so servers that create worlds at runtime grew those maps for the lifetime of the process. - **Predictive pre-loading could stop the whole engine** when a tracked player's last-known world had been unloaded. - **A failed chunk request deleted an entire pre-generation run** — hours of work, with a log line that blamed the wrong thing. - **Pre-generation tripped the safeguard built to exclude it**, clamping view distance while the plugin generated terrain by itself. - **`/vdt history` blamed tick load for changes that had nothing to do with it**, reporting `decrease (mspt=1.9)` on an idle server. It now names the bound that was actually exceeded. - **The pre-generation ETA could be off by a factor of a hundred**, reporting `2m 20s` for a run with hours left. It follows the generation rate now, and says so plainly while it cannot yet be known. - **`/vdt update` reported the wrong version** when up to date, and **messages.yml shipped incomplete** — the whole `/vdt pregen` command surface existed only as code defaults and could not be customised. - Plus the chunk-complexity spiral, the diagonal pre-loading path, `/vdt profile` restoring properly, and several accounting fixes inside a pre-generation run. ### Under the hood The test suite went from 9 to **38**. Every fix in this release was verified against the previous code first — a test that passes both before and after proves nothing. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.9.4-BETA > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Three fixes to how a pre-generation run accounts for itself, one to what `/vdt history` says a decrease was for, and a readable operating-system chart. ### Fixed - **Chunks from a finished run were charged to the next one.** Chunk requests are asynchronous, so some are always still outstanding when a run is cancelled or completes. Nothing reset the in-flight counter and the callback counted unconditionally, so those late arrivals landed on whichever run came after: it reported terrain it had never built, and the counter could fall below zero — which widened the next run's batch budget past what the config allows. Each run now carries a token, and callbacks that outlive their run are dropped. - **The progress file was trusted as written.** A radius beyond the configured maximum — an old file kept after you lowered the limit, or one edited by hand — resumed a run that `/vdt pregen start` would have refused outright. The same bounds apply now however a run begins. - **An idle server asked the disk for the progress file several times a second.** The automatic trigger called it on every pass, forever, to be told "no" each time. It looks once. - **`/vdt history` blamed tick load for changes that had nothing to do with it.** A server idling at 1.9ms logged `decrease (mspt=1.9, mode=reactive)` while dropping every world from 10 to 6. The change was correct — the worlds sat above the maximum in `config.yml` and were brought into range — but on an idle server that line reads as a malfunction, and the history exists precisely to answer "why is my view distance 6". It now names the bound that was exceeded, and only for the value that actually exceeded it: ``` above the configured maximum (sim 10 > 6, view 10 > 8) — brought into range ``` ### Added - **A readable Operating System chart on bStats.** The built-in one drills down on `os.version`, which on Linux is the raw kernel string — so 90% of servers scatter across roughly 94 slices, the largest holding under 10%, while Windows sits tidily under "Windows 11". That chart is built by bStats and cannot be changed from a plugin, so this adds one beside it keyed on the kernel series: `6.8.0-137-generic` and `6.8.0-124-generic` are two slices in the old chart and one population in reality. Unrecognised version strings are passed through rather than dropped. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.9.2-BETA > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. **Update if you use `/vdt viewdistance` or `/vdt simulationdistance`.** A value above 32 did not just fail — it stopped the plugin until the next reload. ### Fixed - **An out-of-range distance stopped the engine.** `/vdt viewdistance 53` was handed straight to `World#setViewDistance`, which accepts only 2 to 32, and threw. The command checked the lower bound and never the upper one. The throw was the smaller half of it. The override is registered *before* it is applied, so the rejected value stayed in the map: the next check cycle re-applied it, threw again, and because that call sits inside the tick handler it took everything queued behind it with it — override expiry, per-player overrides and every remaining world check. The plugin was effectively dead until `/vdt reload` cleared the override, with only a stack trace to say so. Two more doors led to the same place. Per-world `min`/`max-view-distance`, `min`/`max-simulation-distance` and the `startup-grace` values were all read with a lower bound only, so a typo in config.yml reached the same setter from inside the check cycle. The clamp those needed already existed and was applied to the AFK values, the chunk-generation emergency distance and the profile caps — the per-world settings simply never used it. `applyDistances()` now clamps as a last resort before the Bukkit setters, so no caller can put the engine in that state again. The command itself refuses an out-of-range value outright instead of clamping, so you are told what happened rather than quietly getting a different number than you typed. - **The error message for an unparseable value said the opposite of what was wrong.** Typing `53#` answered "Invalid value (minimum 2)". It now reports the value back along with both bounds. - **Pre-generation tripped the safeguard that is meant to exclude it.** A generated chunk reaches the tracker twice, and the pre-gen claim was consumed by the first arrival before the chunk was marked as seen — so the second arrival found no claim and counted it. Every pre-generated chunk fed the chunk-generation safeguard, which then locked distance increases and pinned view distance to the emergency value while the plugin generated terrain by itself. Only affects servers with `chunk-generation-safeguard.enabled: true`. - **The shipped messages.yml had fallen behind the code.** Every server logged "25 message key(s) are missing" on load, fresh installs included: the whole `/vdt pregen` command surface, the update-download messages and `help.pregen` existed only as code defaults, so none of them could be customised — the keys were not in the file to edit. The advice in that line made it worse, because deleting the file returned the same incomplete copy and discarded any customisation for nothing. The file is complete again, the log names the keys it is falling back on, and the regenerate hint is honest. - **`/vdt update` reported the wrong version when up to date.** It printed the newest version in your accepted channels, while the log line directly above it printed the installed one — the same placeholder meaning two different things in two lines from one command. On a beta build with the default `accepted-release-types`, the newest accepted version is an *older* release, so a server on 2.9.2-BETA was told "up to date (2.8.3-RELEASE)". It reports the installed version now, and says plainly when that version is ahead of anything its channels will offer. - **The pre-generation ETA could be off by a factor of a hundred.** It divided the remaining chunks by a rate that blends two operations differing by two orders of magnitude: checking whether a chunk exists is a disk lookup, building one is a generation pass. A resumed run crossing terrain it had already built reported `1029 chunks/s` and an ETA of `2m 20s` while it was genuinely generating at 11/s with hours of work left. `/vdt pregen status` now shows both rates separately and bases the ETA on generation alone — and says the ETA is not known yet while the run is still only skipping, instead of inventing a number. ### Under the hood The bounds were already in the engine, respected only on the per-player path — where this exact class of bug was first noticed in 2.5, when an out-of-range permission value took that feature down. They are the same bounds for a world, and are named accordingly now. The regression test fails against the previous build with the exact message from the report. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.9.1-BETA > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Bugfix release for the 2.9.0 subsystems. **If you run 2.9.0-BETA or 2.9.0-BETA2 with predictive pre-loading or idle pre-generation enabled, update.** Two of these can take the plugin, or a long pre-generation run, out entirely. ### Fixed - **Predictive pre-loading could stop the whole engine.** A `Location` holds only a weak reference to its world, and reading that world back throws once the reference is cleared. The pre-loader read it off the sample it had stored for each player, so any player whose last-known world had since been unloaded — a minigame arena, a plot world — threw out of the tick handler and took everything after it with it: temporary override expiry, per-player overrides and every world check, on every tick, for the rest of the session. The only sign was a stack trace. `forgetWorld()` was written for exactly this case but clears the engine's per-world maps, and this one is keyed by player. - **A failed chunk request deleted an entire pre-generation run.** Any error from the async chunk request called `cancel()`, and `cancel()` deletes the progress file outright — hours of generation on a large radius, gone, with a log line blaming the server jar whatever the real cause had been. Folia is the likely trigger, since `getChunkAtAsync` can refuse a call issued from the global region scheduler and that is where this runs. It now stops and keeps the progress, so `/vdt pregen resume` picks the run back up. - **`adjustment-mode: off` plus `startup-grace` pinned distances permanently.** Grace forces distances down and relies on the normal check cycle to raise them again; under `off` that cycle returns before it computes anything, so nothing ever did. A server running both stayed at the grace values for the rest of its uptime. Grace is part of distance management, so `off` now skips it and says so in the log. - **A diagonal flight paid for the same chunk twice.** Rounding a normalised movement vector lands consecutive steps on one chunk for any path that is not axis-aligned, and the duplicate could not be caught by the "already loaded" check because the first request had not completed yet. At 45° roughly a quarter of the lookahead budget went on chunks that were already on their way. - **One refused chunk request no longer disables pre-loading for the session.** That branch is now reserved for a genuinely missing API; anything else drops the current path and tries again next cycle. ### Under the hood The pre-loader's path has tests now. Both fail against the previous code: the diagonal case requested eight chunks for six distinct ones, and the unload case requested eight chunks for a world the server no longer had. That is the gap the earlier suite left — it drove pure arithmetic, and neither of these appears until the real method runs against a world. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.9.0-BETA2 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Follow-up to the 2.9.0-BETA subsystems. One new config option, requested by testers running only idle pre-generation / predictive pre-loading without wanting the plugin to touch view/sim distance at all. ### Added - **`adjustment-mode: off`.** Disables automatic sim/view distance management entirely — the world's current distance is left exactly as-is, and only `/vdt simulationdistance`/`/vdt viewdistance` (temporary overrides) can still change it. Idle pre-generation, predictive pre-loading, AFK throttling, per-player fixed distances and MSPT tracking all keep working independently, since they never depended on the distance-management pipeline in the first place. Useful if you only want the pre-generation/pre-loading subsystems and nothing else. - `/vdt simulate` reports `off` mode honestly — it does not compute a target it will never apply. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.9.0-BETA > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. **This is a beta.** Two new subsystems, both off by default. They have had limited testing on real hardware — if you run a server people care about, wait for the stable release or try this on a test instance first. Nothing changes for you unless you switch one of them on. ### Added - **Idle pre-generation.** Builds terrain ahead of time, so players never wait for it. Generating a chunk is the most expensive thing a server does and the one everything else here can only react to; terrain that already exists is read from disk instead, and the chunk-generation safeguard never has to trip at all. It runs automatically once the last player logs off, or on demand: ``` /vdt pregen start world 250 centred on the world spawn /vdt pregen start world 250 --here centred on where you are standing /vdt pregen status progress, rate and ETA /vdt pregen stop pause for good, progress kept /vdt pregen cancel --confirm throw the progress away ``` Three rules keep it from becoming the problem it solves. It throttles against the same rolling MSPT average the distance engine uses, not an instant reading, so the two never form competing control loops. It **stops** rather than slows when free heap runs low, because a slower path to an OutOfMemoryError is still an OutOfMemoryError. And it writes progress to disk, so a crash or a nightly reboot resumes exactly where it left off instead of quietly losing hours of work. It also excludes its own chunks from the chunk-generation safeguard. Without that the plugin would fight itself: pre-gen creates terrain, the safeguard reads that as players outrunning the generator, and everyone's view distance gets clamped. Mind the scale — a radius is entered in chunks but squares into the workload. Radius 250 is about 251,000 chunks; radius 1000 is over four million. Match it to your world border rather than picking a round number. The command warns you when a run is large. - **Predictive pre-loading.** Loads chunks along the path of a fast-moving player, so arriving somewhere does not stall the tick. To be precise about what this is: it makes chunks ready **server-side**. It does not let anyone see further, because the client still receives only what its own view distance covers. What you notice is the absence of a hitch, not a wider horizon. Prediction follows the movement vector rather than the look direction. During elytra flight the view swings around constantly while the flight path stays straight, and it is the path that decides which chunks the server will need. Generation is off by default and should stay that way — with it on this stops being a loader and becomes a second, uncontrolled terrain generator driven by whoever is flying fastest. ### Fixed - **Per-world state was never cleaned up.** Check counters, cluster bonuses, pending reverts and temporary overrides are all keyed by world name and nothing ever removed them. Servers that create worlds at runtime — minigame arenas, per-player plots — grew those maps for the lifetime of the process. - **`version: 1` had sat unread in config.yml since the first release.** Bukkit only writes the default config when the file is missing, so upgrading left every new key absent and the features behind them silently running on code defaults, with no way to notice. The version is now checked on load and missing settings are named individually. - **The README documented no `viewdistancetweaks.vdt.command.profile` permission**, despite 2.8.2 splitting it off from the preset node. ### Changed - `idle-pregeneration.enabled` governs only the automatic zero-player trigger. `/vdt pregen` works regardless — refusing an explicit command because of a config key would be the plugin overruling an operator who had already said what they wanted. - `pause-when-players-online` likewise applies only to automatic runs. A manual run keeps going and stays throttled by MSPT and free memory. ### Under the hood The project now has a test suite. The `never-reduce-below-players` bug fixed in 2.8.2 — which drove a struggling server to maximum distance — survived three careful code reads and fell out of a headless sweep in minutes. That sweep now lives in the repository: JUnit 5 driving the real distance calculation through dynamic proxies, covering the distance invariants across every mode and option combination, the profile overlay, the config key fallback, version ordering and the chunk arithmetic. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.8.3 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. A configuration change: auto-update is now off by default, and the notification setting has a name that says what it does. ### Changed - **`auto-update` is off by default.** Installing a new version unattended is a decision an admin should make deliberately rather than inherit from a default. Set `auto-update.enabled: true` if you would rather not think about updates again — the feature itself is unchanged and still verifies every download against Modrinth's published SHA-512 before staging it. **This only affects new installations.** If you already have a config.yml from 2.8, 2.8.1 or 2.8.2, it contains `enabled: true` as a literal value and will keep updating automatically. Change it by hand if you want it off. - **`update-checker` is now called `update-notify`**, because that is what it does: it tells you a new version exists, it never installs anything. The old key still works, so an existing config that switched it off stays quiet. Nothing to change unless you want to. - `/vdt update download` still fetches an update on demand whatever these settings say, so turning auto-update off costs you nothing in convenience. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.8.2 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Bugfix release. The first item is serious if you use `never-reduce-below-players` — that option could drive a struggling server straight to maximum distance. ### Fixed - **`never-reduce-below-players` forced distances UP instead of holding a floor.** It raised the target to the raw player count *after* the step limits and the min/max clamp had already been applied, so nothing downstream could contain it. A world with 20 players jumped from simulation distance 4 to its configured maximum of 12 in a single check — with `max-increase-step: 1` — and did so at 120ms MSPT, in every adjustment mode. The more players a world held, the harder it pushed, which is exactly backwards from what an overloaded server needs. It is a floor now, never a lift: it can hold a decrease back, but it can no longer manufacture an increase, and it can never exceed the current distance. The documented purpose is unchanged — a world sitting at 10 with 10 players still refuses to drop below 10 under load. - **`/vdt profile normal` restored almost nothing, and profile switches accumulated.** Profiles overwrote the config values in place with nothing to fall back on. Switching `event-mode` → `night-mode` kept every event-mode value the second profile did not happen to mention, and `normal` reset only the two distance caps. A server therefore stayed on its event thresholds indefinitely after the event, with nothing to indicate it; only `/vdt reload` recovered. Every profile-writable value is now restored before an overlay is applied, so switching is stateless and `normal` means what the config and the command have always claimed. - **`/vdt status` announced updates by string inequality.** Left over from the 2.8 rewrite, which moved everything else to a numeric comparison. Since `getLatestVersion()` now returns the newest *compatible* version rather than the newest overall, any difference was reported as an update — a server on a beta build with `accepted-release-types` at `release` was told to "update" to the older release it had already passed. - **Chunk complexity sampling only ever looked in one direction.** The spiral that picks sample chunks around each player derived its offset as `ring - abs(dx)`, which is never negative, so every sample landed in the same half-plane. A hopper array one chunk in the opposite direction was invisible, and with `use-complexity-weighting: true` that multiplier moves real chunk budget between worlds. The spiral now walks complete rings — indices 0 to 80 cover exactly the 9×9 block around the player, all four quadrants equally. - **The auto-updater did not check where the update folder points.** An empty `settings.update-folder` in bukkit.yml resolves to the plugins folder itself, which would have staged the download on top of the running jar instead of beside it. It now refuses and says why. ### Verification The distance calculation was executed headlessly across 577,155 parameter combinations — every adjustment mode, MSPT from 5 to 120, player counts, step sizes and option combinations — checking that view never falls below simulation distance, that both stay inside their configured bounds, that step limits hold, that profile caps are never exceeded, and that `prioritize-simulation-distance` never sheds view distance while simulation distance still has room. All hold. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.8.1 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. Bugfix release. Two of these affect anyone using per-world check intervals or the chunk generation safeguard, so updating is worthwhile even if 2.8 looked fine. ### Fixed - **`/vdt simulate` did not predict what the engine actually does.** The preview summed each world's weight as `chunk-weight × priority`, while the live path also divides by the complexity multiplier. With `use-complexity-weighting: true` the two therefore worked from different totals, and the preview showed proactive targets that never happened — which is precisely what `/vdt simulate` exists to rule out. - **Chunk generation was counted twice.** A newly generated chunk fires both `ChunkPopulateEvent` and `ChunkLoadEvent` with `isNewChunk()`, and both were counted. Every rate was roughly double the truth, so `chunks-per-second-threshold: 15` actually tripped at around 7 real chunks per second, and `/vdt status` reported inflated numbers. The safeguard was consistently twice as aggressive as configured. Both listeners are still in place — the second one covers server paths where populate does not fire — but a chunk is now counted once per window. - **A world with its own, shorter `ticks-per-check` ran its first check on placeholder values.** The shared snapshot (MSPT, weight sum, variance) was only refreshed one full global `ticks-per-check` after the start delay. Any world configured to check more often than that fired first and read the startup placeholders: an MSPT of 50, which sits above the default decrease threshold, so it cut distances on a perfectly healthy server, with a weight sum of 0.0001 feeding the proactive formula on top. This happened after every start, every `/vdt reload` and every `/vdt enable`. Servers on the default config were not affected. - **`/vdt profile` required the `preset` permission.** Those are not the same level of trust: `/vdt preset` rewrites your config.yml on disk, while `/vdt profile` only lays a temporary overlay that `normal` undoes. Granting someone the in-event switch also granted them the config file. It now uses its own node, `viewdistancetweaks.vdt.command.profile`. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.8 > Dynamic view distance and simulation distance adjustment per world, driven by what your server can actually carry at that moment. This release adds an auto-updater and rewrites the update check that sits underneath it. ### Added - **Auto-update.** The plugin now keeps itself current. It is **on by default**; set `auto-update.enabled: false` near the top of config.yml if you would rather approve every update yourself. The running jar is never modified. A new release is downloaded into Bukkit's update folder (`plugins/update/`) under this plugin's own file name, and your server installs it on the next **start**. So it is downloaded now and active after your next restart. No plugin can safely swap its own jar underneath a running server, and this one does not pretend otherwise. It only ever touches ViewDistanceTweaks. The single file it can write is named after this plugin's own jar, so it cannot replace or stage anything for another plugin. - **Downloads are verified before they are installed.** Every file is checked against the SHA-512 hash Modrinth publishes for it, and discarded on a mismatch rather than moved into place. Size limits and the declared file size are enforced too. - **`auto-update.require-matching-game-version`** (default `true`) only accepts releases that list the Minecraft version your server actually runs. - **`auto-update.accepted-release-types`** (default `release`) controls which Modrinth channels may be installed. Add `beta` if you want fixes early. - **`/vdt update download`** stages an update immediately, even with auto-update switched off, so you can test the whole path without editing the config and restarting. - **`update-checker`** is now documented in config.yml. It has been read since it was introduced but appeared in no shipped config, so the only way to find it was reading the source. ### Changed - **The update check was rewritten.** It used to pull the first `version_number` out of the raw JSON with `indexOf` and compare it to the running version with `equals`. That is enough to print a notice, but not to decide what to install: it ignored which Minecraft versions and loaders a release declares, treated any difference as "newer" so a rolled-back release looked like an update, and would have matched that string anywhere in a changelog. It now parses properly, filters by loader, game version and release channel, and compares versions numerically, so **2.10 correctly sorts above 2.9** instead of below it. - Both the check and the download run entirely off the main thread. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.7.1 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. Bugfix release for the features introduced in 2.7. If you enabled **AFK throttling** or **chunk complexity weighting** in 2.7, please update — both were broken. Everything else in 2.7 was unaffected. ### Fixed - **AFK player throttling did nothing unless another feature happened to be enabled.** The periodic sweep that applies it was gated on the two per-player fixed-distance options, which are off by default — so switching on *only* `afk-player-throttling`, the most obvious way to use it, silently had no effect at all. - **Chunk complexity weighting worked in reverse.** The cost multiplier was applied so that an expensive world received a *larger* share of the chunk budget instead of a smaller one — roughly four times the real cost for a world with twice the per-chunk cost, while starving the cheap world that could actually have afforded it. Expensive chunks now correctly mean fewer of them. - **Emergency relief could stay engaged forever.** Running `/vdt disable` while relief was active left that world's weather cleared and its daylight cycle frozen indefinitely; only a reload or restart brought them back. Relief is now released as soon as the plugin is switched off. - **`/vdt status --fixed` did not list AFK-throttled players**, despite that command existing precisely to show which players the plugin is currently overriding. Each entry now also states whether the value came from a permission or from the AFK throttle. - **Chunk generation tracking was not thread-safe on Folia**, where chunk events fire on region threads: the counter maps could be corrupted or throw `ConcurrentModificationException` mid-cycle. ### Performance - The cluster bonus is computed once per check cycle instead of three times, each of which ran an O(n²) pass over a world's players. - Complexity sampling no longer allocates an array of every loaded chunk (15k+ entries on a busy server) just to inspect 40 of them. It now samples around players, which is both cheaper and a better sample — the chunks that cost tick time are the ones near players. - Removed two unused methods left over from 2.7. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.7 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. **Every new feature below is off by default.** Updating from 2.6 without touching your config changes nothing about how the plugin behaves. ### New - **AFK player throttling** — a player standing still at spawn doesn't need the same distances as one flying an elytra. Idle players drop to configured minimums and the chunks they free up go back into the global budget for players who are actually playing. Uses Paper's own idle timer, or EssentialsX's AFK state when that plugin is present so `/afk` counts immediately. An explicit `viewdistancetweaks.fixed.<n>` permission wins over the throttle. - **Chunk generation safeguard** — MSPT variance detection notices the stutter that terrain generation causes, but not the cause. This counts chunks that are genuinely being *generated* (not merely read from disk) and can lock increases and hard-clamp view distance while someone crosses unexplored terrain at elytra speed. - **Density-based scaling** — twenty players scattered across a world load twenty separate rings of chunks; twenty players around one community farm load almost the same chunks. The flat per-player formula can't tell those apart and starves clustered worlds of distance they could easily afford. Players within a configurable radius now grant bonus distance, scaled by how much of the world's population is actually in that cluster. - **Emergency relief** — last resort for a world that has run out of distance to give back. Once simulation *and* view distance sit at their minimum and the server is still overloaded, thunderstorms are cleared and the daylight cycle frozen. Both are restored once MSPT recovers, and each world's original weather and `doDaylightCycle` setting is remembered — a world you deliberately kept frozen stays frozen. - **Memory safeguard** *(the one exception: on by default)* — distances don't only cost CPU, every extra ring of chunks stays resident in the heap. A server can sit at a perfect 20 ms MSPT and still be one increase away from spending every tick in garbage collection. While free heap is below the configured percentage, all increases are blocked regardless of MSPT; decreases always stay allowed. - **Profiles** — named overlays for thresholds, step sizes and hard distance caps, switchable in-game with `/vdt profile <name>` instead of editing the config mid-event. Ships with `event-mode` and `night-mode` examples. Caps apply after every other rule, so a cap of 8 genuinely means 8. - **Chunk complexity weighting** — an ocean chunk costs almost nothing; a chunk holding a 500-hopper sorting system can dominate a tick on its own, yet the old formula counted both as one unit. Chunks are now weighted by their tile entities. Inspecting chunks is itself work, so this samples a bounded number per world rather than scanning everything. ### Changed - Relicensed from MIT to **GPLv3**. - `/vdt status` gained lines for the active profile, free heap, throttled AFK players, active emergency relief, per-world chunk generation rate, cluster bonus and complexity multiplier — each shown only when the matching feature is enabled. - New `/vdt profile [name]` subcommand with tab-completion. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional - [EssentialsX](https://modrinth.com/plugin/essentialsx) — optional, only for AFK detection ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.6 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### New - **Every message is now configurable** via a new `messages.yml`, including an optional global prefix. Any key you delete falls back to the built-in English text, so an outdated file after an update can never leave you with blank lines — missing keys are simply counted in the console on startup. - **Per-player fixed simulation distance**, the counterpart to the existing fixed view distance: grant `viewdistancetweaks.simfixed.<value>` (2–32, highest wins) to pin an individual player's simulation distance. Unlike view distance this genuinely costs server performance, so it is off by default and meant for a handful of staff, not a donor rank. - **`/vdt status --fixed`** lists every player who currently holds a fixed view or simulation distance, the value in effect, and their world's current distance next to it — so you can confirm at a glance whether a permission actually took hold instead of guessing. - **`/vdt history`** shows the last 20 applied distance changes with how long ago they happened, the world, the old and new values, and *why* each one was applied (MSPT, high variance, prediction, revert, temporary override, startup grace, or a manual command and who ran it). Answers "why is my view distance 6 right now?" after the fact. ### Changed - **Empty worlds no longer jump to their maximum distance.** A world with no players was previously driven to its configured maximum; the first player to walk in then landed on a fully maxed-out world, and `max-decrease-step` could only walk it back down one notch per check — exactly the load spike `startup-grace` exists to prevent. Empty worlds now drop to their minimum instead, configurable via the new `proactive-mode-settings.empty-world-target` (`min` / `max` / `keep`). Set it to `max` to restore the old behaviour. ### Experimental - **Folia support.** All scheduling now runs through an adapter that uses Folia's regionized schedulers when present and the classic Bukkit scheduler otherwise; per-player changes are dispatched to each player's own region thread. On Paper the behaviour is unchanged. This has been compiled and verified against Paper but **not yet tested on a live Folia server** — if you run Folia, please report back before relying on it. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.5 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed **per-player fixed view distance not working at all**: the `viewdistancetweaks.fixed.<value>` permissions were only evaluated after the main engine had passed its start-delay and startup-grace period, and were skipped entirely while the plugin's master switch was off. With the default config that meant the permission did nothing for roughly the first 7 minutes after every restart. It is now handled independently of the main engine. - Fixed the override **silently never being installed when the world already happened to sit at the same value**: the check that decided whether an update was needed could not tell "this player has a fixed override" apart from "this player is simply following the world", so no override was ever applied and the player quietly drifted back to the world's distance on the next adjustment. This is why the feature appeared to work for some players but not others. - Fixed **revoking the permission having no effect**: players stayed pinned to their old fixed view distance until they relogged, even after the permission was removed or the feature was switched off in the config. They are now handed back to their world's normal distance right away. - Fixed the `permission-prefix` option being **case-sensitive**, so any prefix containing uppercase letters matched no permission at all. - Fixed out-of-range permission values (e.g. `viewdistancetweaks.fixed.64`) throwing internally and taking the whole feature down — values are now clamped to the valid 2–32 range. - Fixed unsupported servers **failing silently**: if the per-player view distance API is unavailable, a clear warning is now logged instead of the feature quietly doing nothing. - Fixed fixed-view players not being re-applied after **respawning**, and added proper cleanup of tracking data on disconnect. - `/vdt reload` now applies changed per-player-fixed-view settings immediately instead of waiting for the next check cycle. - The plugin is now **enabled by default** in a freshly generated `config.yml`. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.4 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed **manual distance overrides not actually holding**: `/vdt simulationdistance` and `/vdt viewdistance` without `--duration` were supposed to lock the value until `/vdt reload`, but the automatic engine would silently start adjusting away from it again within a few check cycles. It now actually holds until reload, as intended. - Fixed a connection leak in the update checker (connections weren't always being closed properly). - Improved thread-safety in the performance-tracking code used by bStats metrics, avoiding a rare race condition. ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.3 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed **MSPT-variance false positives on low-load servers**: standard deviation is symmetric, so a server smoothly bouncing between e.g. 4–18ms tripped the same `variance-threshold` as one bouncing between 40–55ms, even though only the second case is actually causing lag. Added `mspt-variance.min-avg-mspt-to-trigger` (default `25.0`) — variance is now only treated as overload once the average MSPT is also at or above this value ### Config Changes - New (optional): `reactive-mode-settings.mspt-tracker-settings.mspt-variance.min-avg-mspt-to-trigger` (default `25.0`) ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.2 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed **`prioritize-simulation-distance` being silently bypassed** by MSPT-variance-triggered decreases: a decrease caused by high tick-to-tick variance (rather than a sustained high MSPT average) was reducing view distance right alongside simulation distance, even with `prioritize-simulation-distance: true` set — it should have held view distance steady until simulation distance hit its configured minimum - Fixed **per-player fixed view distance (`viewdistancetweaks.fixed.<value>`) flashing back to the world default** on join, on world change, and briefly after any world-wide view distance change — overrides are now re-applied immediately in all three cases instead of waiting for the next scheduled check (previously up to ~30s later) - Added `%viewdistancetweaks_mspt_stddev_color%` placeholder — colors based on current MSPT standard deviation vs. `variance-threshold` - Documentation: added the previously-undocumented `%viewdistancetweaks_mspt_stddev%` placeholder to the placeholder list, and removed a dead `chunk-counter-settings.exclude-overlap` config example that the plugin never actually read ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.1 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Added **config validation**: the plugin now warns on startup/reload for config mistakes that used to fail silently — unknown `adjustment-mode` values, `increase-mspt-threshold` set higher than `decrease-mspt-threshold`, `mspt-variance.min-samples` exceeding `sample-window`, and per-world `max-view-distance` conflicting with `min-simulation-distance` - `mspt-tracker-settings.collection-period` now actually does something: MSPT is tracked over the plugin's own rolling window sized to this value, instead of being silently capped at Paper's internal ~5-second tick-time buffer - Added **per-world check intervals**: any world can now override `ticks-per-check` independently via `world-settings.<world>.ticks-per-check`, instead of every world sharing one global timer. A busy overworld can react quickly while a quiet nether/end checks far less often - Added **`/vdt preset <small-server|large-network|performance-first>`**: applies a bundle of tuned config values in one command instead of hand-editing ~40 options from scratch - `/vdt status` now shows a per-world "next check" countdown, accounting for per-world interval overrides and any still-pending start-delay - Added a new bStats chart tracking how often `revert-increase-if-overloaded` fires — a high count signals the configured thresholds/step sizes are too aggressive for that server - Internal: replaced the single global check-scheduler with a per-tick dispatcher in `DistanceEngine`, needed to support independent per-world intervals; `/vdt simulate` and the real check cycle now share one target-calculation method so they can never drift apart ### New Permissions - `viewdistancetweaks.vdt.command.preset` — required for `/vdt preset` ### Config Changes - New (optional): `world-settings.<world>.ticks-per-check` - Removed: `world-settings.<world>.chunk-counter-settings.exclude-overlap` (was loaded but never had any effect) ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v2.0 > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed the default `enabled` value in `config.yml`, which was `true` despite the comment right above it telling admins to leave it `false` until configured — new installs now correctly start disabled as documented - Fixed a missing permission node: `/vdt simulate` was permission-gated in code but never registered in `plugin.yml`, so permission plugins couldn't grant it properly - Added `softdepend: [PlaceholderAPI]` to `plugin.yml` to guarantee correct load order with PlaceholderAPI - Removed the unused `chunk-counter-settings.exclude-overlap` world-setting — it was loaded from config but never actually had any effect, silently misleading anyone who configured it - Removed stray backup files that were accidentally being bundled straight into the shipped plugin JAR - Cleaned up stale/incorrect code comments left over from earlier refactors ### New Permissions - `viewdistancetweaks.vdt.command.simulate` — required for `/vdt simulate` (now properly registered instead of relying on OP fallback) ### Removed - `world-settings.<world>.chunk-counter-settings.exclude-overlap` — dead config option with no effect ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.9-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Added **MSPT variance detection**: catches unstable server performance (high tick time fluctuation despite a healthy average MSPT) as its own overload signal — configurable via the new `mspt-variance-settings` block under `reactive-mode-settings.mspt-tracker-settings` - High variance now triggers a virtual overload: lowers view distance by `max-decrease-step` and can optionally block increases (`block-increase-on-high-variance`), even while average MSPT looks fine - Added `/vdt simulate [world]` — runs the decision logic and shows what would change on the next cycle, without touching any live values - `/vdt status` and `/vdt mspt` now display the current MSPT standard deviation with color-coded indicators - Added PlaceholderAPI placeholder `%viewdistancetweaks_mspt_stddev%` - Internal refactor: decision logic (`computePlan`) is now fully decoupled from side effects (`applyPlan`), making `/vdt simulate` possible and paving the way for more accurate planning in future updates ### New Permissions - `viewdistancetweaks.vdt.command.simulate` — required for `/vdt simulate` ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.8-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed `max-decrease-step` defaulting to `3`, causing simulation/view distance to drop faster than intended out of the box — default is now `1` - Added optional per-player fixed view distance: grant a permission like `viewdistancetweaks.fixed.<value>` to keep a specific player's client-side view distance fixed, regardless of the world's managed value (e.g. for mods/streamers) — disabled by default - Added optional startup grace period: force a low, fixed simulation/view distance immediately on plugin start instead of whatever the world already had, avoiding an instant overload on a cold-started server — normal adjustment resumes automatically after the configured duration, disabled by default - Fixed `never-reduce-below-players` raising simulation/view distance even when that dimension was explicitly excluded via `exclude: true` — excluded dimensions are no longer touched ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.7-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed the view-distance >= simulation-distance invariant being enforced too early — `never-reduce-below-players` could raise simulation distance again afterward, potentially leaving simulation distance higher than view distance - Fixed `min-view-distance` being silently forced to at least `min-simulation-distance` — your configured value is now respected as-is - Fixed mixed simulation/view distance changes (one increasing while the other decreases) being misclassified as a pure decrease, letting an increase skip the `passed-checks-for-increase` confirmation delay entirely - Fixed the update-checker console log box having misaligned borders when version strings differ in length - Fixed `/vdt viewdistance <value>` silently overriding the requested value with no explanation when it was below the current simulation distance — now shows a warning instead ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.6-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed `max-increase-step` and `max-decrease-step` having no effect in `reactive` mode — the underlying calculation always produced a fixed +/-1 change regardless of how far MSPT was past the threshold, so there was never anything for the step-size cap to actually limit. The step size now scales with how far MSPT is over/under the threshold (one extra step per 5ms), still capped by the configured `max-increase-step` / `max-decrease-step` ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.5-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed mixed mode being able to jump simulation/view distance straight to its maximum in a single check when server load suddenly dropped (e.g. players clustering together), instantly re-overloading the server and requiring a slow step-by-step decrease afterward - Added `max-increase-step` and `max-decrease-step` options under `reactive-mode-settings` (default: `1` and `3`) — limits how many steps simulation/view distance may change by in a single check, in each direction - Added `revert-increase-if-overloaded` option under `reactive-mode-settings` (default: `true`) — if an increase immediately overloads the server on the very next check, it's rolled back right away instead of crawling back down through the normal decrease delay ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.4-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Added `prioritize-simulation-distance` option under `reactive-mode-settings` (default: `false`) — when enabled, view distance is only reduced once simulation distance has already hit its configured minimum for that world. Simulation distance has a bigger impact on TPS, while reducing view distance causes visible chunk flicker for players, so this avoids touching view distance unless it's really needed ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.3-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed MSPT measurement reporting a flat ~50ms regardless of actual server load — the plugin was timing the interval between its own repeating scheduler task executions, which reflects Bukkit's internal tick-slot cadence rather than real tick duration. MSPT is now read directly from Paper's own tick-time API and correctly tracks real server performance - Fixed `chunk-weight` having no real effect on view/simulation distance calculations — the weight was factored into an internal chunk-count total that proactive mode never actually used. Each world's `chunk-weight` now correctly determines its share of the global chunk budget - Fixed an unnecessary object allocation on every `getSettings()` call ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.2-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Translated all console logs, chat messages, and command output to English ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

## ViewDistanceTweaks v1.1-RELEASE > Dynamic view distance and simulation distance adjustment per world — lightweight, fully configurable, and built for performance-critical servers. ### Changelog - Fixed mixed mode's increase branch being identical to the decrease branch — increases now correctly use `Math.max` instead of duplicating the `Math.min` decrease logic - Fixed a possible division by zero when `ticks-per-check` is set below 20 - Fixed `mspt-collection-period` never being validated to be greater than 0 - Fixed `announce-changes-in-chat` iterating over all players even when no one is online - Fixed `calcProactiveSimDist` ignoring the `totalTicking` parameter instead of using it in the calculation - Fixed `colorize()` corrupting world names that contain an `&` character - Added bStats metrics integration - Added a built-in update checker ### Dependencies - [Paper 1.21.x / 26.x](https://papermc.io/) — required - [PlaceholderAPI](https://modrinth.com/plugin/placeholderapi) — optional ### Support Join our Discord: **dc.gg/paperstream** *Author: LucasTHCR*

English Config.