LC2H | Lost Cities: Multithreaded

Support your language in the mod!

What is LC2H?

LC2H is a performance and stability rework layer for The Lost Cities.

It does not replace Lost Cities' profiles, structures, style, or gameplay identity. It changes how the expensive work is prepared, scheduled, cached, and applied.

The whole point is simple: stop Lost Cities from cooking the Minecraft thread every time a city starts generating.

Old Lost Cities work is heavily tied to shared state, serial planning, and expensive repeated lookups. That is fine for a normal worldgen workload, but it gets ugly fast when you combine big cities with terrain mods, structures, trees, highways, tunnels, and Distant Horizons.

LC2H moves the safe planning work away from the main thread, keeps Minecraft mutations on the thread Minecraft expects, and prevents duplicated work from multiplying across worldgen workers.

V4.0.0 - The actual rebuild

V4 is not V3 with another cache thrown on top. A large part of the execution model was rebuilt because the old hybrid path had reached the point where every fix created two more weird edge cases.

The new pipeline is built around scoped planning, immutable data, multichunk ownership, and safe application.

• Expensive planning data is captured once and reused instead of being rebuilt by every worker.
• World and dimension caches are scoped correctly so old worlds cannot leak data into new ones.
• Single flight planning prevents several workers from calculating the same expensive region at the same time.
• Multichunk buildings keep their complete footprint instead of being cut off by another chunk.
• Roads, highways, tunnels, city floors, and terrain edge work are planned together.
• Cross chunk trees are captured and replayed without leaving chopped trunks or floating leaves.
• Structure protection prevents many vanilla and modded structures from clipping through cities.
• Distant Horizons keeps ownership of its own distant generation path.
• Failed fast paths fall back to CPU instead of blocking worldgen or corrupting the world.

Minecraft still owns the final block mutations. LC2H does not blindly write the world from random worker threads and pray that nothing explodes.

City safe structure handling

Cities and normal Minecraft structures do not naturally understand each other's boundaries. That is how you get roofs cut in half, buildings inside streets, trees hanging in the air, and structures spawning directly through city blocks.

V4 adds a proper structure protection path which tracks city and multibuilding footprints instead of making a tiny per block guess every time a structure asks whether it can place.

• Structure starts can be rejected when they overlap protected city space.
• Large multibuildings reserve their full footprint before placement.
• Smaller structures can still use the remaining space instead of killing an entire city area.
• Road and tunnel areas are protected from being exposed by unrelated structures.
• Tree and foliage work can be deferred when it crosses chunk borders.
• Floating vines, grass, and leftover vegetation can be cleaned in bounded batches.

This is still a beta, so unusual structure mods should be tested. The system is designed to fail safely instead of silently destroying a city chunk.

The performance numbers

No made up “100x faster” nonsense. These are the real results from the V4 rewrite benchmark across the verified hot path runs.

These are focused hot path measurements, not a universal chunks per second guarantee. Actual worldgen speed depends on your CPU, disk, terrain, structures, lighting, fluids, render distance, Distant Horizons, and every other mod fighting for the same machine.

The important part is that these gains come from doing less work, not just throwing more workers at an expensive path.

Parity and safety checks

• Noise parity error stayed below 4.1e-16.
• 65,536 city random parity samples completed with zero double mismatches.
• Integer city parity completed with zero mismatches.
• GPU results are validated before they are published.
• Unavailable or failed GPU paths automatically fall back to CPU.

The goal is not to force everything onto the GPU or into a worker thread. The goal is to make the fast path cheap while keeping exact fallback behavior for unusual terrain and modded worldgen.

Vulkan and Quantified API

When Quantified API finds a working Vulkan runtime, LC2H can use Vulkan for selected compute heavy planning tasks.

• Vulkan is probed and warmed up outside the main game loop.
• Work is submitted in batches instead of one tiny dispatch per chunk.
• GPU output is checked before it can affect the world.
• Runtime failures fall back to the optimized CPU path.
• OpenCL remains optional and only activates when the runtime binding is actually present.

If your machine has no usable GPU runtime, LC2H still works. You just get the optimized CPU path instead.

The config UI and benchmark

Open the Mods menu, select LC2H, and open Config.

The config screen includes cache controls, power settings, diagnostics, and an integrated benchmark.

• Chunks loaded
• Effective CPM
• Average and minimum TPS
• Tick timing
• Freeze count
• Hardware information
• Final benchmark score

Run the benchmark on your own pack before and after changing settings. Comparing a clean test world to a giant modpack and calling the result a performance regression is cooked from the start xd

V2 vs V3 vs V4

V2 focused on partial async hooks layered on top of Lost Cities. It reduced some lag, but a lot of expensive logic still depended on shared state and the main thread.

V3 pushed much further with broader async scheduling, caching, tree replay, GPU experiments, and safer application work.

V4 is the next step. It focuses on making the hot paths cheaper, keeping ownership clear, preventing duplicated planning, and handling large multichunk worldgen properly.

The goal with V4 is not to hide a slow algorithm behind more threads. The goal is to make the algorithm cheaper first, then scale it safely.

The V4 story

LC2H started because Lost Cities was one of those mods where the world looked amazing but the game could absolutely fall apart when the generator got busy.

V1 and V2 were early experiments. They proved that parts of Lost Cities could be moved around, but they were still built around too many old assumptions.

V3 was the first major jump. It introduced proper async planning, safer translation layers, cache work, tree replay, and the early Quantified API integration.

V4 is where the old hybrid approach finally had to go. The project became too large for endless patches, so the important parts were rebuilt around scoped state, immutable plans, multichunk ownership, and measurable hot paths.

There were a lot of cursed worldgen bugs along the way. Cut trees, broken roofs, missing structures, terrain getting flattened into a wall, GPU paths that looked fine in logs but did nothing, and caches that behaved perfectly until the world was rejoined xd

That is why V4 is marked beta. The architecture is much cleaner and the measured hot paths are much cheaper, but real modpacks still need real testing.

LC2H V4.0.0-BETA | Created by Admany | BlackRift Studios :DDD