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 preserves the art, profiles, and gameplay identity of Lost Cities, but replaces the entire execution model under the hood.

V3 moves the full generator pipeline off the Minecraft main thread.

City generation no longer blocks ticks or freezes the game loop. Exploration stutter is replaced with smooth async work.

City chunks are generated asynchronously, in parallel, and only applied to Minecraft when the results are safe.

V3.0.0 - An Engineering Marvel

V3.0.0 is not a patch and not an extension of V2.

It is a ground up rebuild that restructures Lost Cities into a job based, fully async pipeline.

• explicit job-based generator API
• enterprise grade async scheduler
• parallel worker pools under load
• translation layer for thread-safe data
• multi tier caching system
• optional GPU acceleration via Quantified API

V3 is an engineering marvel that pushes Lost Cities into a performance tier it was never designed to reach.

City Safe Structure System

V3 introduces a structure control system built for dense city environments.

Vanilla and modded world structures are prevented from spawning inside city boundaries.

This guarantees no structures generate inside buildings, clip through streets, or float above cities.

V3 also cleans common worldgen artifacts:

• removes floating vines
• clears bugged tall grass placements
• prevents vegetation from spawning mid air above cities

The result is clean city skylines with zero visual corruption.

Config UI - Commands Replaced

All command based configuration has been removed in V3.

Configuration is now handled through a proper in game UI.

Path:

• Mods + LC2H + Config
• Config button is located near the Done button

The config UI includes an integrated benchmarking tool. When run, it produces a final performance score. Higher scores indicate better performance. On heavily modded packs such as ChaosZProject or ZombieCraft, a score in the 30k-40k range is considered excellent. This means LC2H was fast enough to keep up with Minecraft's generation workload while still maintaining performance headroom.

• benchmarking tool is located at the bottom of the config screen

The UI acts as the control center for power modes, caches, diagnostics, and performance testing.

V2 vs V3 - Technical Differences

V2 focused on partial async hooks layered on top of Lost Cities.

Most heavy logic still depended on the main thread and shared unsafe state.

V3 fully separates Lost Cities logic from Minecraft execution flow.

• V2 reused existing generator hooks
• V3 replaces the generator pipeline entirely
• V2 reduced lag spikes
• V3 eliminates them under normal load
• V2 was limited by MC thread safety
• V3 enforces thread isolation by design

This architectural change is what allows V3 to scale with hardware instead of fighting it.

Performance Snapshot

Higher is faster. Visual comparison only.

Speed
|" 
|"                     |-^
|"                     |-^       
|"                     |-^
|"          |-^        |-^        3. LC2H V3
|"          |-^        |-^
|" |-^      |-^        |-^        2. Vanilla
|" |-^      |-^        |-^   
   1.       2.         3.         1. LC2H V2 (Behind Vanilla by 20%)

V3 is designed to keep city generation ahead of vanilla, even at high density.

Why V3 Feels So Fast

Lost Cities compresses expensive logic into a small generation window.

V3 expands that window by executing the heavy steps in parallel async worker pools.

In V3.2.0 the main‑thread apply path is now pull‑based instead of push‑based. Async producers no longer flood the queue - the game thread pulls a safe amount of work each tick based on current TPS. This keeps stalls away, cuts CPU spikes, and makes load times far more predictable even in heavy modpacks.

• main thread is no longer the bottleneck
• workers stay saturated
• caches prevent rebuild storms

Optional GPU acceleration offloads selected compute heavy paths when supported.

The Translation Layer

Lost Cities was never designed to be thread safe.

V3 extracts required data, converts it into a safe representation, and isolates worker threads from unsafe state.

This is what allows nearly all Lost Cities work to run off thread without corruption or crashes.

The V3 Story

V3 is what I wanted to see with V1 of LC2H, or as we knew it, Lost Cities: Multithreaded.

V3 development started on September 17, 2025. The first prototypes were small, mostly reworks of V2 and V1 caching, partial multithreading, and early experiments.

Around mid October, I came to the conclusion that V3 had to take the step I should have done with V1, but I was too scared.

That decision created Quantified API. Its purpose was to bring the tools to me, and to everyone, without having to remake the same systems over and over per mod.

I will be honest: V3 caused immense pain at times. I cried, and I gave up more than once, because the complexity was real.

Multithreading The Lost Cities is on par with multithreading Minecraft's chunk generation. One mishandled piece of data, and it stops working as it should.

All I want to say is that I am proud. Proud of the work, and how much I had to give up in real life to make this. I hope this helps modpacks and others push performance forward, and leaves the old days of Lost Cities lag behind us.

LC2H - Version 3.2.0 - Created by Admany - BlackRift Studios - January 20, 2026