3D world exploration with AI: landmarks, procedural terrain and generated worlds

A big world is easy to make and hard to make interesting. Point a noise function at a plane and you get a thousand square kilometres of hills in an afternoon; walk across them for ten minutes and you will be bored. The difference between a world you explore and a world you merely cross is not size or fidelity. It is whether the space keeps asking you questions: what is that tower, where does this river go, why is there smoke over that ridge. Generative AI makes the first problem easier still: a model can now produce a scene from a prompt. It does nothing on its own for the second. This piece is for AI game designers building that questioning into a 3D world, from the old design principles that still decide whether a generated world is worth walking through, through the procedural techniques that give terrain and structure, to what AI-generated assets, world models and agents can and cannot add today.

Why people explore at all

The most useful framing comes from psychology rather than games. George Loewenstein’s information-gap theory of curiosity (1994) describes curiosity as what we feel when we notice a gap between what we know and what we want to know. Two details matter for design. Curiosity needs some knowledge to start: you cannot be curious about something you have no frame for. And it is strongest when the gap looks closable. A mystery that seems hopeless produces indifference, not drive.

Translated into a 3D world, that gives a simple rule: show the player something partially, and make reaching it look possible. A ruin glimpsed through trees, a light on a far hill, a cave mouth halfway up a cliff. Each is a small, visible gap. Exploration is the act of closing gaps, and the craft is in opening the next one just as the last one closes.

Landmarks, weenies and sightlines

Theme park designers worked this out long before open-world games. Walt Disney popularised the term “weenie” for a large, eye-catching structure that pulls visitors through a space; the classic example is Sleeping Beauty Castle at the end of Main Street, U.S.A. at Disneyland. The street is a funnel, the castle is the reward at the end of it, and once you arrive, the hub reveals new weenies in every direction.

Urban planning offers a more systematic vocabulary. Kevin Lynch’s The Image of the City (1960) found that people build mental maps of cities from five kinds of element:

Lynch’s element	What it is	In a game world
Paths	Channels people move along	Roads, rivers, ridgelines, animal trails
Edges	Boundaries that break continuity	Cliffs, coastlines, walls, biome borders
Districts	Areas with a recognisable character	Biomes, towns, ruined quarters
Nodes	Focal points where paths meet	Crossroads, camps, fast-travel points
Landmarks	External reference points seen from afar	Towers, mountains, a giant tree

If players get lost in your world, one of these is usually missing. Procedural worlds in particular tend to be rich in districts (biomes) and poor in landmarks and paths, which is why they so often feel samey.

The team behind The Legend of Zelda: Breath of the Wild described a related idea at CEDEC 2017, often reported as the “triangle rule”. Triangular hills and rock forms give players a choice of going over or around, and they hide what is behind them, so cresting one reveals something new. Large landmarks such as towers were placed to draw the eye; smaller triangles controlled what you could see at any moment. Journey takes the minimal version of the same idea: a mountain visible from almost everywhere, so the player never needs a map to know where to go.

Practical rules to take from all this, and to check every generated area against:

• Every view should contain a goal. Stand anywhere and turn around; if nothing is worth walking towards, that spot is dead.
• Use occlusion as much as visibility. Hills, forests and bends in a path control the rhythm of reveal. An open plain shows everything at once and spends all its curiosity in one look.
• Give landmarks unique silhouettes. Players navigate by shape at a distance, not by texture. Two identical towers are one landmark and a source of confusion.
• Let geography be the map. A river always runs downhill to the sea; a road connects settlements. Worlds that obey legible rules let players reason their way around.

Wayfinding without a waypoint

A quest marker closes every information gap for the player, which is precisely why it kills exploration. The alternatives all work by making the world itself readable. Lighting pulls the eye: a lit doorway in a dark scene is a stronger cue than any arrow. Colour coding helps, sparingly, for things like climbable surfaces. Sound is underused: a waterfall heard before it is seen is an invitation. And directions given in terms of the world (“past the burnt mill, towards the twin peaks”) make the player look at the world rather than the HUD.

Outer Wilds is the strongest argument for knowledge as progression. You can, in principle, go almost anywhere from the start; what you gain by exploring is understanding, recorded in your ship’s log. The world never changes to let you in. You change.

Procedural terrain: noise and its limits

Most procedural terrain starts with gradient noise. Ken Perlin developed his noise function in the early 1980s, after working on Tron, and received an Academy Award for Technical Achievement for it in 1997. He later introduced simplex noise (2001), which scales better to higher dimensions and has fewer directional artefacts.

A single layer of noise gives smooth, blobby hills. Real terrain comes from summing several layers (octaves) at increasing frequency and decreasing amplitude, a technique usually called fractal Brownian motion (fBm). Below is a compact, deterministic version using value noise, which is simpler than Perlin’s gradient noise but shows the same structure:

// Deterministic integer hash -> [0, 1)
function hash2(x, y, seed) {
  let h = Math.imul(x, 374761393) ^ Math.imul(y, 668265263) ^ Math.imul(seed, 1442695041);
  h = Math.imul(h ^ (h >>> 13), 1274126177);
  h ^= h >>> 16;
  return (h >>> 0) / 4294967296;
}

const smooth = (t) => t * t * (3 - 2 * t); // smoothstep easing
const lerp = (a, b, t) => a + (b - a) * t;

// Value noise: random values at grid corners, smoothly interpolated
function valueNoise(x, y, seed) {
  const x0 = Math.floor(x), y0 = Math.floor(y);
  const tx = smooth(x - x0), ty = smooth(y - y0);
  const a = hash2(x0, y0, seed), b = hash2(x0 + 1, y0, seed);
  const c = hash2(x0, y0 + 1, seed), d = hash2(x0 + 1, y0 + 1, seed);
  return lerp(lerp(a, b, tx), lerp(c, d, tx), ty);
}

// Fractal Brownian motion: sum octaves, each finer and quieter
function fbm(x, y, seed, octaves = 5, lacunarity = 2, gain = 0.5) {
  let sum = 0, amp = 1, freq = 1, norm = 0;
  for (let i = 0; i < octaves; i++) {
    sum += amp * valueNoise(x * freq, y * freq, seed + i);
    norm += amp;
    amp *= gain;
    freq *= lacunarity;
  }
  return sum / norm; // stays in [0, 1)
}

function heightmap(width, depth, scale, seed) {
  const h = new Float32Array(width * depth);
  for (let z = 0; z < depth; z++) {
    for (let x = 0; x < width; x++) {
      h[z * width + x] = fbm(x / scale, z / scale, seed);
    }
  }
  return h;
}

To use it in Three.js, build a PlaneGeometry with width - 1 by depth - 1 segments (so it has exactly width * depth vertices), rotate it flat with geometry.rotateX(-Math.PI / 2), set each vertex’s Y from the array, and call computeVertexNormals(). Raising each height to a power, say h ** 2, flattens the valleys and sharpens the peaks, which already looks much more like land.

Noise has a well-known ceiling. It produces texture, not places. Nothing in an fBm field knows about rivers, passes or where a town should go. The worlds that feel designed layer further passes on top: hydraulic erosion to carve valleys, rivers traced downhill from high points, settlements placed where water and flat ground meet, roads routed between settlements with a pathfinder that dislikes slopes. Each pass adds one of Lynch’s elements that noise cannot. No Man’s Sky, released in 2016, is the famous case study in both directions: an enormous number of noise-driven planets, and a long run of updates since launch that largely added structure, purpose and things to find on them.

Structure: wave function collapse and L-systems

For things built from parts, such as towns, dungeons and interiors, constraint-based generation works better than noise. Wave function collapse (WFC), released by Maxim Gumin in 2016, builds on Paul Merrell’s earlier model synthesis work. The name borrows from quantum mechanics, but the algorithm is plain constraint solving. Every cell starts with every tile as possible; you repeatedly pick the most constrained cell, fix it, and propagate the consequences to its neighbours.

grid: every cell holds the set of all tiles
loop:
    cell = uncollapsed cell with the fewest options (lowest entropy),
           ties broken randomly
    if none remain: done
    choose one tile for cell, weighted by tile frequency
    push cell onto stack
    while stack not empty:
        c = pop(stack)
        for each neighbour n of c:
            allowed = tiles compatible with any remaining option of c
                      in that direction
            if options(n) shrinks after intersecting with allowed:
                if options(n) is empty: contradiction -> restart or backtrack
                push n onto stack

The adjacency rules either come from hand-authored tile sockets or are learned from a small example image. Oskar Stålberg’s Townscaper and Bad North are well-known uses of WFC-style generation in released games. The strength is local coherence: every wall meets a wall, every road connects. The weakness is the reverse: WFC knows nothing about large-scale shape, so a WFC town has no high street and no centre unless you constrain those in first.

L-systems, introduced by the biologist Aristid Lindenmayer in 1968 to model plant growth, are string-rewriting grammars. A rule such as F → F[+F]F[-F]F, applied repeatedly and drawn with a turtle that moves on F, turns on + and - and saves and restores its position on [ and ], produces convincing branching plants. The Algorithmic Beauty of Plants by Przemyslaw Prusinkiewicz and Lindenmayer (1990) remains the standard text and is free online. They are good for vegetation, root systems, river deltas and branching road networks. As with WFC, they give you local detail; layout is still your job.

The pattern across all three techniques is the same. Procedural generation is excellent at the middle scale, at filling, and poor at intention. Place landmarks and major paths by hand, or with a small set of explicit rules, then let generation fill the space between. The same division of labour holds for generative AI: the model fills, the design decides.

AI-generated 3D assets and worldbuilding

Generative models now reach every layer of this stack, with very different levels of maturity.

Single assets are the most usable. Image-to-3D and text-to-3D models such as Microsoft’s open-source TRELLIS and Tencent’s Hunyuan3D produce textured meshes in minutes. For props, rocks, ruins and set dressing seen at middle distance, the results are often good enough after cleanup. Close-up hero assets still need a 3D artist: topology, UVs and consistent style are where generated meshes most often fall down.

Whole scenes are newer. 3D Gaussian splatting (Kerbl et al., SIGGRAPH 2023) made photoreal captured scenes renderable in real time, and generators now output splats directly. World Labs’ Marble, released in November 2025, generates persistent 3D worlds from text, images or video that you can move through and edit. These are excellent for mood pieces and previsualisation; turning them into a playable space with collision, navigation and logic is still work.

Interactive world models are the frontier. Google DeepMind’s Genie 3 generates a navigable world frame by frame from a prompt, at 720p and 24 frames per second, holding consistency for a few minutes. There is no mesh and no map underneath, only a model predicting the next frame from your input. For exploration this is fascinating, because the world is literally made as you look at it, and limiting, because a landmark you cannot reliably return to is not a landmark.

For an AI game designer, AI is most useful today in the unglamorous layer in between: writing generation rules and tools, naming places, drafting the lore that explains why the ruin is there, and producing variations of existing assets. Language models are good at the meaning of a place, which is precisely what noise lacks.

Populating the world

An empty world, however well composed, is a diorama. Agents, increasingly AI-driven ones, give the player reasons to look: a trader on the road suggests a town ahead, smoke suggests people, a herd fleeing suggests a predator. Agents are also landmarks in motion, and they are the cheapest way to make generated terrain feel inhabited.

The same level-of-detail thinking that applies to rendering applies here. Agents near the player run full behaviour; distant ones are simulated statistically and promoted when approached. Memory, planning and LLM-driven dialogue are covered in more depth in AI-driven NPCs: LLM agents and the future of living simulations. For exploration specifically, the most valuable thing an agent can do is point: tell the player about somewhere they haven’t been, truthfully, from world state. A rumour is an information gap delivered by a character.

Exploration as a game loop

Exploration becomes a loop when each discovery funds the next search. The basic cycle is:

1. Notice a gap: a landmark, a rumour, a strange sound.
2. Commit to reaching it, accepting some cost in time, risk or resources.
3. Travel, with the journey producing smaller discoveries along the way.
4. Arrive and resolve the gap, with a reward: an item, a story fragment, a view.
5. Reveal new gaps from the new vantage point.

The reward in step four does not have to be loot. Knowledge, traversal abilities that reopen old areas, and simply a better view all work, and the best rewards change how the player reads the rest of the map. What breaks the loop is predictability: once players learn that every ruin contains the same chest, the gap closes before they arrive and step two stops happening. Procedural and AI-generated worlds are especially prone to this, so deliberately vary what each kind of site contains and keep some sites authored.

Pacing matters too. Alternate dense and sparse areas, so that emptiness reads as anticipation rather than filler, and make sure the player is rarely more than a minute or two of travel from something new on the horizon.

Takeaways

• Curiosity is a visible, closable information gap; good exploration design opens a new one as each closes.
• Use landmarks (Disney’s “weenies”), sightlines and occlusion deliberately; Lynch’s paths, edges, districts, nodes and landmarks are a useful checklist.
• Prefer readable worlds over waypoints: light, sound, silhouettes and geography that obeys rules.
• Noise and fBm give convincing terrain texture but no places; add erosion, rivers, settlements and roads as explicit passes.
• WFC and L-systems give strong local coherence and no large-scale intent; place landmarks and major paths first, and let generation, procedural or AI, fill between them.
• Generated meshes are useful for props today, generated scenes for mood and previs, and real-time world models are promising but not yet persistent.
• AI agents make worlds legible and point players onward; rumours are information gaps delivered by characters.
• Exploration is a loop of notice, commit, travel, resolve and reveal, and predictability is what breaks it.