Chunker

Supported MC Versions:
Minecraft 1.20.5+ (Java 21 or higher)

Supported Severs:
Spigot, Bukkit, Paper, Pufferfish, Purpur

Overview
Chunker is designed to be more efficient and resilient compared to traditional pre-generators. Traditional pre-generators often keep track of hundreds of thousands of chunks in memory, leading to significant issues in the event of a crash. Chunker's approach minimizes the amount of data tracked, reducing the impact of crashes and improving overall performance.

It works best on Paper forks, where it utilizes asynchronous functionality for faster performance. Performance for Bukkit/Spigot has been optimized compared to the default PaperLib implementation, providing 2-3x faster results than other pre-generators.

The pre-generation can be set to run by default when there are no players on the server, and it will shut down when any players connect. This option can be changed in the `settings.yml`. You can also modify the load each world will put on the server and distribute the load however you like.

For example, if you just want to pre-generate the overworld, you can enable `auto_run` in the `world` and set `parallel_tasks_multiplier` to your thread count to utilize 100% CPU load. You can also customize the `task_queue_timer`, `parallel_tasks_multiplier`, `print_update_delay`, and `radius` in the `settings.yml` individually per world.

Key Differences

1. Reduced Memory Usage

Other pre-generators maintain a large in-memory database of chunks, which can grow to hundreds of thousands. This leads to high memory consumption and an increased risk of losing hours of progress during a crash. Chunker limits the amount of data tracked, only keeping necessary information in memory.

2. Minimal Data Loss

In case of a crash, traditional pre-generators can lose a significant amount of progress due to the extensive data they manage. Chunker is designed to handle crashes more gracefully. At most, it will lose the chunk it was processing at the time of the crash.

3. Efficient Chunk Processing

Chunker ensures that already processed chunks are not redone. This is achieved through a strategic method of determining the next chunk for generation. If a chunk is reloaded, it is instantly unloaded, avoiding redundant processing and saving resources.

4. Parallel Task Management

Chunker utilizes an efficient parallel task management system, leveraging the available CPU cores optimally. The load on the server scales linearly with `parallelTasksMultiplier`. If you want a lighter load, you can set a smaller `parallelTasksMultiplier`.

To see how it works in more detail, you can check out the wiki page.

Config

• On non-paper servers, the async functionality will not be used.
• I recommend you go into your paper server's paper-global.yml and update these:

• Adjust io-threads and worker-threads to match your CPU’s thread count. Default settings utilize only half.
• Usage: /pregen ParallelTasksMultiplier PrintUpdateDelayin(Seconds/Minutes/Hours) world Radius(Blocks/Chunks/Regions)

Command Usage
Examples:

/pregen 4 10s world default

• Pre-Generate the overworld
• 4 async parallel processes loading chunks
• Prints logs every 10 seconds
• default Pre-Generates to the world border of the selected world, you can use this if you set your world border manually using /worldborder set #

/pregen 6 5s world 1000b

• Pre-Generate the overworld
• 6 async parallel processes loading chunks
• Prints logs every 5 seconds
• 1000 block radius, (1000 / 16) = 62.5, rounded to 62 chunks, then squared to get total chunks, 62x62 = 3844 Chunks that will need to be processed

/pregen 2 2m world_nether 500c

• Pre-Generate the nether
• 2 async parallel processes loading chunks
• Prints logs every 2 minutes
• 500 chunk radius, squared to get total chunks, (500 * 500) = 250,000 Chunks that will need to be processed

/pregen 1 12h world_the_end 100r

• Pre-Generate the end
• 1 async parallel process loading chunks
• Prints logs every 12 hours
• 100 region radius, 1 region is (32 * 32) chunks, to get the radius we multiply (32 * 100) = 3200 squared to get total chunks, (3200 * 3200) = 10,240,000 Chunks that will need to be processed

Command Settings
ParallelTasksMultiplier

• Recommendation: Stay below your thread count.
• Function: Limits the number of parallel chunk load tasks.
• Calculation: Multiplied by the number of threads available at server initialization. For example, if your server starts with 12 threads, the maximum number of parallel tasks allowed when ParallelTasksMultiplier is set to 6 will be 72.

Performance Examples:

• ParallelTasksMultiplier = 6:
• pregen 6 5s world 100c
• Chunks per second: Avg. ~100 ± 4 (on a 5600x CPU, depending on server activity and other system tasks)
• Time: Finished in 1 Minute 39 Seconds

• ParallelTasksMultiplier = 12:
• pregen 12 5s world 100c
• Chunks per second: Avg. ~200 ± 4 (on a 5600x CPU, depending on server activity and other system tasks)
• Time: Finished in 49 Seconds

Summary:

• Load Management: Determines the load on your server. Scales linearly ~ 17-18 chunks per `ParallelTasksMultiplier`.
• Small Number: Lower load, fewer chunks per second. Good if you just want to run it in the background.
• Large Number: Higher load, faster chunk processing.
• Best Practice: Start at 1 and increase by 1 until you encounter constant overload or reach your thread count.

World

• Determines what world you want to pregenerate.
• Tab autocomplete will fetch all the vanilla worlds in the server and show them to you.
• Then you can choose which world you want and off you go.

Radius

• Determines the radius of chunks that will be pre-generated.
• The supported units are Blocks, Chunks, and Regions.
• To use it, you just have to add the letters b, c, or r next to the actual number.
• For example, 20000b is a 20000 block radius, 500c is a 500 chunk radius, or 30r is a 30 region radius.

Commands:

• /pregen: /pregen <ParallelTasksMultiplier> <PrintUpdateDelayin(Seconds/Minutes/Hours)> <world> <Radiusin(Blocks/Chunks/Regions) or default> Pre-Generate any of the dimensions; overworld, nether, and end.
• /pregenoff: Turn off pregeneration process.

Permissions:
(Default OP)

• chunker.pregen: Grants permission to use the pre-generation command with customizable parameters.
• chunker.pregenoff: Grants permission to disable pre-generation using the /pregenoff command.
• chunker.*: Provides access to all Chunker commands.

settings.yml