Scaling Minecraft World Editing from 50K to Billions of Blocks
Minecraft is a game about building things. But when your edits get big enough—say, filling a 50,000-block area with stone—the game's original tools would freeze the entire server. Every player would disconnect. The server might crash completely.
I co-created FastAsyncWorldEdit (FAWE) and PlotSquared, two projects that changed how Minecraft servers handle massive world operations. We built these tools in-house first, then released them to the open source community for real-world battle testing. Today, these tools let servers process billions of blocks without any interruption to players—and the projects have grown to sustain multiple full-time open source contributors.
The Problem
WorldEdit is the standard tool for editing Minecraft worlds. Need to copy a building? Clear an area? Replace all the stone with diamond? WorldEdit handles it. But there was a fundamental problem: WorldEdit did everything on the main server thread.
Minecraft servers run on a single main thread that must process 20 ticks per second. That's 50 milliseconds per tick. If any operation takes longer, the server falls behind. Stack up too much work, and players experience lag, rubber-banding, or complete disconnections.
A moderately large edit of 50,000 blocks could freeze a server for seconds. Bigger edits—the kind professional build teams actually need—would crash the server entirely. Server operators had to choose between creative freedom and server stability.
The existing solutions were band-aids: limiting edit sizes, warning users not to make big edits, or simply accepting that large operations meant downtime. For servers hosting creative build competitions or professional build teams, this wasn't acceptable.
The Solution: Asynchronous Everything
The core innovation in FAWE was moving all world editing operations off the main thread. Instead of blocking the server while processing an edit, FAWE queues operations and handles them in the background. The main thread keeps running smoothly while edits happen asynchronously.
But asynchronous world editing creates new problems. Minecraft worlds are divided into 16x16 chunks, and the game expects exclusive access to chunk data. Multiple threads touching the same chunk can corrupt world data or crash the server. We needed thread-safe access to world data without killing performance.
Chunk Batching and Queuing
FAWE groups all edits by chunk. When you make an edit that spans multiple chunks, FAWE sorts every block change into per-chunk queues. Then it processes one chunk at a time, applying all queued changes in a single batch. This approach:
- Minimizes the time the main thread needs to spend on any single chunk
- Prevents race conditions between chunks
- Allows massive edits to be spread across many server ticks
- Keeps memory usage predictable regardless of edit size
Memory Management
Large edits can involve billions of blocks. Storing every block change in memory would exhaust any server. FAWE uses disk-backed storage for history and clipboard operations. Your 10-billion-block selection doesn't need 10 billion blocks of RAM—it streams from disk as needed.
We also implemented palette compression. Minecraft worlds tend to have lots of repeating patterns. Instead of storing "stone" a million times, FAWE stores the pattern once and references it. This typically reduces memory usage by 90% or more.
Parallel Processing
For operations that don't need to touch the live world—like analyzing a region or generating terrain—FAWE can use multiple CPU cores in parallel. This makes generation and analysis operations dramatically faster on modern multi-core servers.
PlotSquared: Managing Creative Spaces at Scale
PlotSquared grew from the same technical foundation. Creative servers need to give players individual plots of land to build on. The simple version of this is easy: divide the world into a grid and track who owns each square.
But at scale, plot servers face the same problems as WorldEdit:
- Plot clearing - When a player leaves, their plot needs to be reset to empty. Clearing a large plot used traditional methods would freeze the server.
- Plot copying - Players want to copy their creations between plots. Large builds meant large freezes.
- World generation - Plot worlds need to generate the same grid pattern infinitely. The generation had to be fast enough to not lag players exploring new areas.
PlotSquared uses FAWE's asynchronous infrastructure for all of these operations. Clearing a plot happens in the background. Players can copy massive builds without any server lag. World generation stays smooth even under heavy load.
Scaling to Millions of Plots
PlotSquared also needed to handle metadata for millions of plots efficiently. Which player owns which plot? What are the plot settings? Who's allowed to build there?
We implemented a custom database layer that caches active plots in memory while keeping the full dataset in SQLite or MySQL. The cache system uses LRU eviction to keep memory bounded while maintaining fast access to frequently-used plots.
Integration with the Minecraft Ecosystem
Both projects needed to work with the broader Minecraft ecosystem. Different server platforms (Spigot, Paper, Sponge, Fabric) have different APIs. Different Minecraft versions change internal structures. Protection plugins, economy plugins, and countless other systems all expect to interact with world edits and plot management.
We built a platform abstraction layer that lets the core logic work identically across all supported platforms. When Minecraft updates and breaks internal APIs—which happens regularly—we only need to update the platform adapters, not the entire codebase.
The API we exposed became a foundation for other developers. Hundreds of plugins now integrate with FAWE and PlotSquared, from build competition systems to automated terrain generators.
Observations
Async isn't always faster, but it's always more responsive. Some operations actually take longer total time when done asynchronously due to coordination overhead. But players don't notice because the server never freezes. Perceived performance matters more than benchmark numbers.
Memory pressure drives architecture. The decision to use disk-backed storage wasn't about speed—it was about not crashing servers with large operations. Constraints shape design in productive ways.
Open source at scale requires structure. With hundreds of contributors over the years, we learned to maintain clear coding standards, comprehensive documentation, and thorough code review. The projects survive because new contributors can understand and extend the code.
Breaking changes hurt adoption. Every time we changed the API, plugins depending on us broke. We learned to maintain backward compatibility aggressively, deprecating old methods rather than removing them, and providing clear migration paths.
Results
Today, FastAsyncWorldEdit and PlotSquared power thousands of Minecraft servers worldwide:
- Billions of blocks can be edited without any server lag
- Sub-second response for operations that previously took minutes
- Zero downtime for plot management operations
- Multiple FOSS jobs created through the project's growth and adoption
The projects have been downloaded millions of times. They're standard infrastructure for creative servers, build teams, and anyone doing serious world editing in Minecraft.
What started as an in-house solution grew into something much larger. The content you see in Microsoft's Minecraft Marketplace—the digital storefront for Bedrock and Pocket Edition—gets created by professional build teams working in Java Edition, then exported using FAWE's tools. Our software became part of the pipeline that feeds Microsoft's multi-billion dollar game brand.
Both projects remain actively maintained and continue to evolve with new Minecraft versions and server platforms. The CI/CD infrastructure I set up in 2013 still runs today without modification—over a decade of automated builds, releases, and community support without requiring ongoing attention.
The best tools disappear into the work. Server operators don't think about FAWE or PlotSquared—they just build.