How to optimize view distance for better TPS

Optimizing view distance is a critical endeavor for any Minecraft server owner aiming to achieve and maintain a healthy Ticks Per Second (TPS). The balance between providing players with expansive visual horizons and ensuring smooth, lag-free gameplay is delicate. A higher view distance, while visually appealing, places an exponentially increasing burden on server resources, primarily impacting the CPU and RAM. Understanding the intricacies of how view distance interacts with server performance is paramount to creating an enjoyable experience for all players.

Key Mechanics Influencing Server Performance

To effectively optimize your server, it’s essential to grasp the fundamental mechanics at play. These elements directly dictate how much work your server has to do and, consequently, how well it performs.

• View Distance: This setting directly controls the number of chunks that are loaded and subsequently sent to players. Chunks are 16×16 block sections of the world. The greater the view distance, the farther players can see, but this comes at a significant cost to the server.
• Chunk Processing: Each loaded chunk is not merely a static image. The server must actively process various data within it. This includes block data, managing entities (mobs, items, players), handling tile entities (chests, furnaces, beacons), calculating lighting updates, and processing redstone mechanics. The more chunks loaded, the more of these calculations the server must perform.
• Exponential Workload Increase: A crucial point to understand is that increasing view distance does not result in a linear increase in server workload. Instead, higher view distances lead to an exponential increase in the number of loaded chunks. This dramatically escalates the demand for both server CPU and RAM, which in turn can cause a significant drop in TPS.
• TPS (Ticks Per Second): This metric is the ultimate indicator of your server’s overall performance. Minecraft servers operate on a tick-based system, with 20 ticks per second being the ideal and healthy rate. If the server cannot process all necessary calculations within the allotted 50 milliseconds per tick, the TPS will drop below 20.0, leading to noticeable lag for players.
• Simulation Distance (Minecraft 1.18+): Introduced in Minecraft 1.18 and later versions, simulation distance is a separate but equally important setting. It specifically controls how far the server actively processes game mechanics. This includes crucial elements like mob spawning and AI, crop growth, redstone contraptions, and the movement of entities. It dictates the “active” radius around players.
• Server View Distance as a Hard Cap: Regardless of a player’s individual client-side render distance settings, the server’s view distance acts as a hard cap. Players cannot render or see more chunks than what the server is configured to send them. This means that even if a player sets their client render distance to 32, if the server’s view distance is 8, they will only ever see 8 chunks.

Step-by-Step Optimization Process for Server Owners

Adjusting view distance and simulation distance requires direct access to your server’s configuration files. Follow these steps carefully to implement changes:

• Step 1: Access Server Configuration: Begin by accessing your Minecraft server’s control panel. If you manage your server directly, you will need to locate and edit the `server.properties` file, which is typically found in the root directory of your server installation.
• Step 2: Stop the Server: It is imperative to stop your Minecraft server completely before attempting to make any changes to its configuration files. Editing these files while the server is running can lead to data corruption or prevent the new settings from being applied correctly.
• Step 3: Locate Configuration Entries: Open the `server.properties` file using a plain text editor. Within this file, you will need to find the entries for `view-distance` and `simulation-distance`.
• Step 4: Set Desired Values: Modify the values associated with `view-distance` and `simulation-distance`. These values are measured in chunks. For instance, common recommendations include setting `view-distance` between 5 and 7 chunks, and `simulation-distance` between 4 and 6 chunks.
• Step 5: Save Changes: After inputting your desired values, save the modified `server.properties` file. Ensure it is saved with the correct filename and extension.
• Step 6: Restart the Server: Once the file is saved, you can now restart your Minecraft server. The new view distance and simulation distance settings will be applied during the server’s startup process.
• Step 7: Check Server Software Settings (if applicable): If you are utilizing optimized server software like Spigot, Paper, or Purpur, it is crucial to also check their specific configuration files. For example, in `spigot.yml`, there is often a `view-distance` setting. This should be adjusted to match or be lower than the `view-distance` set in `server.properties` to ensure consistency and prevent conflicts.

Important Tips for Effective Optimization

Beyond the basic configuration, several strategies and considerations can further enhance your server’s performance and stability.

• Relationship Between Distances: Always ensure that your `simulation-distance` is set equal to or lower than your `view-distance`. This is crucial for optimal performance, as it prevents the server from actively processing mechanics in chunks that are not even visible to players.
• Recommended Configuration: A widely accepted and effective setup for many servers is to configure `view-distance=8` and `simulation-distance=5`. This provides a reasonable visual range while keeping the active processing area manageable.
• General Value Recommendations: For the majority of Minecraft servers, a `view-distance` between 5 and 7 chunks and a `simulation-distance` between 4 and 6 chunks are generally recommended. These values strike a good balance between visual quality and performance.
• Minimum View Distance: While lower view distances improve performance, setting it too low can negatively impact gameplay. A minimum of 4 chunks for view distance is generally considered acceptable for navigation and combat, as anything lower can make the game feel disorienting or difficult to play effectively.
• World Pre-generation: To prevent performance spikes and lag as players explore new areas, consider pre-generating your world. Tools like Chunky can generate chunks in advance, eliminating the server’s need to generate them on-the-fly, which is a CPU-intensive task.
• Performance Monitoring: After making any adjustments, it is vital to monitor your server’s performance. Utilize in-game commands such as /tps to check real-time performance, or more advanced profiling tools like /timings (available on Spigot/Paper) or external tools like Spark. This allows you to assess the impact of your changes.
• Optimized Server Software: Running your server on optimized software is perhaps one of the most impactful performance upgrades. Distributions like Paper, Pufferfish, or Purpur include numerous performance enhancements, bug fixes, and optimizations that significantly improve TPS compared to vanilla Minecraft.
• Dynamic View Distance Plugins: For servers with fluctuating player counts or resource demands, dynamic view distance plugins can be invaluable. These plugins automatically adjust the server’s view distance in real-time based on the current TPS, scaling it down during periods of high load to maintain stability and scaling it back up when resources are available.
• Client-Side Player Optimization: Educate your players on how they can improve their own client-side FPS. Lowering their individual render distance settings in their video options can greatly reduce the strain on their computer.
• Client-Side Mods: Recommend client-side performance mods to your players. Mods such as Sodium, Bobby, and Nvidium are renowned for significantly optimizing render distance and overall client-side performance, allowing players to experience smoother gameplay even with higher server view distances.

Common Mistakes to Avoid

Many server owners inadvertently make choices that hinder performance. Being aware of these common pitfalls can save you a lot of troubleshooting time.

• Excessively High View Distance: A frequent mistake is setting the view distance too high, often under the mistaken belief that having abundant RAM is the sole factor for good performance. While RAM is important, the CPU’s speed is critically important for processing the sheer volume of chunks and their associated data. High view distances will quickly overwhelm even powerful CPUs.
• Ignoring Simulation Distance: Especially in Minecraft versions 1.18 and newer, overlooking the `simulation-distance` setting is a significant error. It is a major contributor to performance issues because it dictates the active processing of game mechanics. Neglecting it can lead to lag even if the view distance seems reasonable.
• Insufficient Load Testing: A server that performs flawlessly with a single player might struggle immensely under a realistic load of many players. Failing to test server performance under conditions mimicking your expected player count can lead to unexpected lag spikes during peak hours.
• Increasing View Distance on a Lagging Server: If your server’s TPS is not consistently at 20.0, it indicates existing performance issues. Increasing the view distance in such a scenario will only exacerbate the problem, leading to further drops in TPS and a worse player experience. Address existing performance bottlenecks first.
• Simultaneous Setting Changes: When troubleshooting performance, avoid modifying multiple server settings at once. Changing several parameters simultaneously makes it incredibly difficult to pinpoint which specific change caused a performance improvement or degradation, complicating future optimization efforts.
• Exclusive Focus on RAM: While sufficient RAM is necessary, it is not the only, or even the primary, factor for server performance. Fast single-core CPU performance is paramount for Minecraft, given its tick-based nature. Additionally, quick storage solutions (like SSDs or NVMe drives) are equally important for rapid chunk loading and data access.
• Simulation Distance Higher Than View Distance: Setting `simulation-distance` higher than `view-distance` is inefficient. The server will actively process game mechanics in an area that is not even visible to players, wasting resources. The effective processing area will always be capped by the `view-distance`.
• Excessively Low Simulation Distance: While lowering `simulation-distance` helps performance, reducing it too much (e.g., below 4 chunks) can disrupt essential game mechanics. Mob farms might not function correctly, redstone contraptions might break due to unloaded components, and general gameplay might feel broken.
• Misconception of Chunk Removal: Lowering view distance does not permanently remove or delete chunks from your world. It simply prevents them from being actively loaded, processed, and rendered by the server and sent to players. The chunks still exist on disk.
• Using Very High View Distances: Employing view distances of 16 or higher on a server is almost guaranteed to lead to severe lag and significant performance issues for the vast majority of server setups, regardless of hardware. Such settings should be reserved for single-player worlds or very specific, highly optimized scenarios.