Game world generation: why levels are giving way to generators
Usually, when people talk about automatic game content creation, they imagine a neural network that draws or assembles individual levels. But there is a more radical approach: getting a language model to write not the levels themselves, but programs that generate those levels. This shift seems small, but in reality it changes the entire optimization: instead of iterating over endless map variations, you can evolve the algorithms themselves — and obtain entire families of levels with the desired properties.
Evolution in which code mutates
In a recent study accepted for publication at the IEEE Conference on Games 2026, the authors tested this idea on four classic games: Sokoban, Zelda, Dangerous Dave, and Lode Runner. Each evolutionary run consisted of an entire level generator written in Python, with a large language model serving as the mutation and crossover operators. That is, not individual maps, but complete programs changed from generation to generation. This makes it possible to search in the space of procedural generators rather than in the space of concrete artifacts — and to find solutions that generalize across many levels at once.
However, this approach has a weak spot: programs quickly grow in size, and useful code fragments get lost among random changes. To fix this, the authors proposed a mechanism called Continual Abstraction Discovery (CAD) — the continuous discovery of abstractions.
How CAD helps evolution
The idea behind CAD is to extract successful primitives from high-fitness programs during evolution and store them in a separate auxiliary module. This module becomes a shared "library" for subsequent generations. In this way, useful patterns are not rediscovered from scratch and are not overwritten by mutations — they accumulate and are reused further.
To understand how effective this is, the researchers ran an experiment with a 2×2 matrix: runs with and without CAD, as well as with and without access to a fixed domain API. A total of 160 full evolutionary runs were conducted, with at least ten runs of 50 generations per experimental cell. This provides a fairly solid statistical basis for conclusions.
Abstractions really work
The results were unambiguous: CAD improved the average final best fitness in all eight comparisons — across all four games and both API variants. Moreover, the "libraries" created during evolution were actively used by the majority of later programs. Interestingly, regardless of the game and run conditions, CAD repeatedly rediscovered the same utilities: level validity checks, reachability checks, and structural primitives. This suggests that such abstractions are not a quirk of a specific task, but fundamental building blocks for game content generation.
What this means for practice
From a practical standpoint, the findings support a simple idea: if we want language models to create good procedural generators, we need not only to encourage "good" programs, but also to give evolution a way to accumulate knowledge. CAD does exactly this — it turns evolutionary search into a process that gradually builds its own domain. Instead of starting from scratch every time, the model learns from previously found solutions and forms reliable building blocks.
Of course, experiments on classic 2D games are only the beginning. But if the approach scales, we may see generators that create entire genres or unexpected game mechanics. And then level evolution will finally transform from content enumeration into the evolution of ideas — written in the language of programs.
