Every large Minecraft world reaches the same moment. Players spread out, exploration accelerates, and the server starts stuttering whenever anyone crosses into ungenerated terrain. The usual fix — “assume the world is too big, buy more RAM” — is wrong for this specific problem. Chunk generation is CPU- and disk-IO-bound, not memory-bound, and on a dedicated node you can pre-generate the world in an offline pass and eliminate the stutter entirely.
This guide is the operational version: how many chunks you are really generating, what it costs in IO and wall-clock time on NVMe, how to run the pre-generation without thrashing the same node your players are on, and how to size storage afterwards. It is aimed at single-node dedicated hosts running Paper or Purpur, though the numbers carry over to Fabric and to other block-based titles.
The real chunk math
Minecraft’s world is 30 million blocks wide in each direction, but nobody generates that. Solve for the region you actually need. A world border of 10,000 blocks in each direction (a 20 k×20 k square) contains 20,000/16 = 1,250 chunks per axis, or 1.56 million chunks. At 15 ms of CPU per chunk on a modern core — a fair average for Paper 1.21 in normal terrain — that is 23,400 core-seconds, or 6.5 hours of pure generation on four parallel workers. Add structure generation and biome blending and real-world throughput lands 20–35% lower.
Disk cost per generated chunk varies with version and terrain. In 1.21 with the standard region format, expect 6–12 KB per chunk on disk for a normal overworld, plus Nether and End. A 20 k×20 k overworld therefore lands around 12–20 GB, and a full three-dimension world with the same border might hit 30–45 GB. Add entities, block entities, and player structures and you should budget 50–80 GB for a mature community world of that size.
Compare that to the numbers people quote: “a Minecraft world can be petabytes.” It can, if you let players explore to 30 million. The point of a world border is to convert an unbounded variable into a fixed, budgetable one. Pick the border from your player count and travel policy, not from fear of missing out.
How many chunks your players actually touch
Server view distance sets the working set. At view-distance=8, each player causes the server to load roughly 17×17 = 289 chunks, but only a subset are ticked: the entity ticking range defaults to view distance + 1 in recent versions, and load-only chunks outside that circle are kept in memory but not simulated. Sizing rule of thumb for steady-state RAM: 1,200–2,000 chunks per 100 concurrent players at view-distance 8, at roughly 60–110 KB of heap per loaded chunk.
That gives 75–220 MB per 100 players of pure chunk cache — which is why “buy 128 GB for 100 players” advice is so wrong. What actually consumes memory is the JVM heap high-water mark plus off-heap allocations from Netty and the NMS chunk cache, and that scales with churn, not player count. A pre-generated world reduces churn to near zero, which is precisely why it also reduces memory pressure and GC pause frequency.
The IO pattern is the other half. Without pre-generation, every player crossing into new terrain triggers synchronous chunk loads mixed with generation writes: random 4 KB reads against 8 KB writes into region files, at thousands of IOPS during a big exploration push. NVMe handles this; SATA SSD and HDD do not, and you get 200–600 ms tick spikes. Pre-generating converts a random-write-heavy workload into a sequential-read workload, which is what the filesystem and page cache are good at.
Running the pre-generation pass
Use Chunky (the Fabric/Paper-compatible fork) on the exact server jar and world you will run in production. Version mismatch is the classic failure: generating with 1.20.4 and then running 1.21 produces mixed-format regions and a repair pass that costs more than the original generation. Copy the world to a scratch directory, run Chunky against the same JVM version, and only then swap it in.
Set parallelism deliberately. Chunky’s default uses all cores, which will starve the tick loop if you run it on the live server. On a dedicated node with 8 cores allocated to Minecraft, give Chunky 4 workers and pin the live server to the other 4 with taskset -c 4-7 or a cgroup CPU weight. Better still: shut the instance down and run the pass offline, accepting 6–10 hours of downtime during a scheduled maintenance window.
Watch two numbers during the pass: chunks per second and disk write throughput. On PCIe 4.0 NVMe with four workers you should see 30–60 chunks/s. If you see 8–12 chunks/s, you are IO-bound — check iostat -x 2 for %util and write await, because a consumer drive whose SLC cache has filled will drop to 400–600 MB/s and stall the whole job. A pass that should take 7 hours will take 30 on the wrong drive.
Don’t let pre-generation cook the node
A fully loaded 8-core pre-generation job draws 90–140 W on the CPU package alone and runs at 100% for hours. On a 1U chassis with a shared rack, that is exactly the workload that reveals marginal cooling. Check inlet temperature and CPU package temperature at the 30-minute mark, not at the end. If you see package temps above 85 °C or any sign of thermal throttling in turbostat, the pass will take materially longer and you should reduce worker count rather than push through.
Also throttle the write path so backups and monitoring do not collapse. Pre-generation writes 12–20 GB in a few hours — trivial for NVMe, but if your backup job fires mid-pass it will read the same region files and double the IO load. Schedule backups outside the window, and disable hourly world backups entirely while the pass runs.
Trimming and storage after the pass
Real pre-generated worlds are more than 60% empty chunks — ocean, void, terrain outside the playable border. A trimming pass removes them and can cut region size by half. Do not trim aggressively on your first pass; keep a full copy of the untrimmed world for a week in case a player’s base sits outside what you assumed was empty. The cost of keeping 20 GB for a week is nothing compared to the cost of a rollback.
For storage, this is a case where RAID 1 on two enterprise NVMe drives is the right answer rather than anything fancier. World data is write-once-then-read-mostly after pre-generation, so RAID 0 earns you nothing, and RAID 5 write amplification on region files is actively harmful. Enterprise drives with high TBW (1 PBW class) matter less here than in Rust or Palworld, because pre-generated worlds generate very little steady-state write.
Keep the region files on the same filesystem as the server, not on a network mount. NFS or SMB adds 1–5 ms per metadata operation, and Minecraft performs a very large number of stat() calls on chunk load. If you need shared storage for multiple instances, use a local NVMe with async replication rather than a network filesystem in the hot path — the same principle that shows up across our hardware tuning guides for dedicated game servers.
Keeping the world bounded after launch
A pre-generated world only stays cheap if the border holds. Set worldborder in the server config or via command, and enforce it with a plugin that prevents teleports and portals from crossing it. Without that, one player with a Nether portal and a boat will recreate the unbounded problem in a weekend.
Run a monthly report on world size and chunk count, and a quarterly top-up pre-generation for any area inside the border that players have opened. A top-up pass of 5,000 chunks takes 20–40 minutes and keeps the steady-state workload flat. Pair that with our dedicated server comparison for hardware sizing if you outgrow the node — but most communities will find that a properly bordered, pre-generated 20 k world fits comfortably on a single 8-core EPYC with 32 GB of RAM for years.

Leave a Reply
You must be logged in to post a comment.