HLODs: The "Low-Poly" Trick That Keeps Your Island Running Smooth

Have you ever zoomed out in Fortnite Creative and noticed that the distant mountains suddenly look like low-res cardboard cutouts? That’s not a glitch; that’s HLODs (Hierarchical Level of Detail) working overtime to keep your frame rate from tanking. If you’ve ever tried to build a massive open-world island and watched your FPS drop into the basement, it’s usually because your computer is trying to render every single leaf on every tree, even the ones three miles away.

In this tutorial, we’re going to demystify HLODs. We’ll learn how to use them to turn your heavy, lag-inducing landscapes into lightweight, high-performance zones. You won’t just learn what they are; you’ll learn how to configure them so your island stays buttery smooth, whether players are right in your face or looking at the horizon.

What You'll Learn

• The Concept: What HLODs are and why your GPU (Graphics Processing Unit) needs them.
• The Setup: How to generate HLODs for your landscapes and static meshes.
• The Tuning: How to adjust "LOD Bias" and generation settings to balance visual quality with performance.
• The Result: A playable, high-FPS island that doesn’t crash when players cluster together.

How It Works

The "Zoomed-Out" Analogy

Imagine you’re holding a high-end camera. When you take a selfie, you see every pore on your skin, every eyelash, and the texture of your shirt. That’s High Detail. But if you zoom out to see the whole city, you don’t need to see the pores on the people across town. You just need to see that there is a person there. If the game engine tried to render every pore on every NPC across the entire map, your computer would explode.

HLODs are the game engine’s way of saying, "Hey, I see you’re far away from that forest. I’m going to replace those 50 detailed trees with one single, low-poly block that looks like a tree from a distance." This is called Level of Detail (LOD).

Hierarchical means it happens in layers.

1. Close Up: You see the detailed tree with leaves, bark, and branches.
2. Medium Distance: The leaves disappear, but you still see the branch structure.
3. Far Away: The tree becomes a simple green cone.
4. Very Far Away: The tree becomes a tiny green dot or disappears entirely into the background.

Why This Matters for UEFN

In Fortnite Creative, your island is a World Partition. This system loads chunks of your map as players move around. But even within those chunks, if you have thousands of complex props (like detailed buildings or dense forests), the engine still has to calculate where every single vertex is.

HLODs pre-calculate these "simplified" versions. Instead of the engine doing the math in real-time for distant objects, it loads a pre-made, simpler version. This saves CPU and GPU cycles, which directly translates to higher FPS and less stuttering.

The Catch: HLODs Are Static

Here’s the most important rule: HLODs are for things that don’t move.

• Good for HLODs: Mountains, buildings, static trees, rocks, fences.
• Bad for HLODs: Players, vehicles, moving platforms, destructible walls.

If you put a moving prop into an HLOD system, it will freeze in place because the HLOD is a "statue" of that object. We’ll cover how to avoid this trap later.

Let's Build It

We’re going to set up HLODs for a simple "Dense Forest" zone. This is a common scenario where players might stand in one spot for a while, and the engine needs to handle a lot of geometry without lagging.

Step 1: Prepare Your Assets

Before we can generate HLODs, we need objects to simplify.

1. Place a Landscape (your terrain) in your island.
2. Scatter some Static Meshes (trees, rocks, buildings) across it. Make sure these are placed in the editor, not spawned by Verse during gameplay (for this initial setup, static placement is best).

Step 2: Enable HLODs in World Partition

1. Open your World Partition settings (usually found in the World Partition tool or settings menu).
2. Look for the HLOD section.
3. Check the box to Enable HLODs.

Step 3: Generate the HLODs

This is where the magic happens. The engine will scan your scene and create simplified versions.

1. In the World Partition settings, find the Generate HLODs button.
2. Click it. The editor might freeze for a moment as it calculates. This is normal—it’s doing the heavy lifting.
3. Once done, zoom out in your editor. You should see that distant objects have changed appearance slightly (they look blockier).

Step 4: Configure the Settings

Not all objects need the same level of simplification. A rock far away can be very blocky, but a building might need more detail.

1. Select your Landscape or Static Meshes.
2. In the Details panel, look for HLOD Settings.
3. Adjust the LOD Bias:
   • Higher Bias: More simplification (better performance, lower quality).
   • Lower Bias: Less simplification (worse performance, higher quality).
4. Critical Setting: Ensure Include Children is checked if you have grouped props (like a tree with leaves as a child mesh).

Step 5: The Verse Integration (Dynamic HLODs)

Wait, what if you want to spawn trees dynamically with Verse? You can’t just put a Verse-spawned prop into the static HLOD system. Instead, you use Verse to manage performance.

Here’s a simple Verse script that demonstrates the concept of managing object detail based on distance, which is what HLODs do automatically for static objects. While Verse doesn’t "generate" HLODs, it can help you manage which objects are active.

# This is a simplified example of how Verse interacts with scene objects.
# Note: Actual HLOD generation is an editor-side tool, not a runtime Verse function.
# This script shows how you might manage object visibility based on distance,
# mimicking the *effect* of HLODs for dynamic objects.

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/VerseTypes }

# Define our "Tree" device
HLOD_Tree_Device := class(creative_device):
    # A variable to store the distance threshold
    # Think of this as the "Zoom Level" where the tree simplifies
    LOD_Threshold: float = 1000.0 # Units away

    OnBegin<override>()<sidescript>:
        # When the game starts, we don't do anything yet.
        # HLODs are pre-generated by the editor.
        pass

    # This event fires every frame
    OnUpdate<override>()<sidescript>:
        # Get the list of players
        players := GetPlayers()

        for player in players:
            # Get player's location
            player_loc := player.GetLocation()

            # Get this tree's location
            tree_loc := GetLocation()

            # Calculate distance (simple Euclidean distance)
            distance := (player_loc - tree_loc).Length()

            # If the player is FAR away, we could hide the dynamic version
            # (In reality, HLODs handle this automatically for static meshes)
            if distance > LOD_Threshold:
                # For dynamic objects, you might set visibility to false
                # to save performance, since HLODs don't apply to them.
                SetVisibility(false)
            else:
                SetVisibility(true)

Wait, why did I include this? Because Verse doesn’t generate HLODs. HLODs are an Editor Tool. The code above shows the logic behind HLODs (hiding/simplifying distant objects), but you should use the World Partition HLOD Generator for static meshes (trees, rocks, buildings). Use Verse for dynamic objects (players, vehicles, props spawned during gameplay).

Try It Yourself

Challenge: Create a "Mega-City" zone with 50 buildings and 100 trees.

1. Place all buildings and trees as static meshes in the editor.
2. Enable HLODs in World Partition.
3. Generate the HLODs.
4. Play your island. Zoom out and walk around.
5. Test: Try moving the LOD Bias slider in the World Partition settings. Does the performance improve? Does the visual quality drop too much?

Hint: If your FPS still drops, check if you have any dynamic props (like moving platforms or Verse-spawned items) in that area. HLODs won’t help those! You might need to simplify those assets manually or reduce their polygon count.

Recap

• HLODs are pre-simplified versions of static objects that kick in when players are far away.
• They are generated by the World Partition tool in the editor, not by Verse at runtime.
• They only work for static objects (buildings, trees, rocks). Dynamic objects (players, vehicles) need other optimization techniques.
• Adjusting LOD Bias lets you trade visual quality for performance.

By using HLODs, you’re letting the engine do the heavy lifting for distant objects, so your players can enjoy a smooth, lag-free experience even in the most detailed islands.

References

• https://dev.epicgames.com/documentation/en-us/uefn/UE/building-virtual-worlds/world-partition/world-partition-hlods
• https://dev.epicgames.com/documentation/en-us/uefn/UE/ue-reference-environments-and-landscapes-in-unreal-editor-for-fortnite
• https://dev.epicgames.com/documentation/en-us/uefn/UE/building-virtual-worlds/world-partition/world-partition-data-layers
• https://dev.epicgames.com/documentation/en-us/uefn/UE/building-virtual-worlds/world-partition
• https://dev.epicgames.com/documentation/en-us/fortnite/streaming-and-hlods-in-unreal-editor-for-fortnite