Baek et al.: Ordering a Level That Is 75% Zelda and 25% Mario, in Plain Words — Fukai Reads

TL;DR

"Give me a level that is 70% Zelda and 30% Super Mario Bros." A paper describing a generator that can take that order appeared on arXiv this March. It comes from five researchers at GIST and Dongguk University in South Korea. They put levels from four games into a single shared space so that text and a mixing ratio can combine them.

There are two ways to mix. One turns each of two written instructions into a row of numbers and adds them together with a weight. The other writes a single sentence such as "based on A, featuring B." The first behaves as the ratio dictates. The second is still weak.

Compared with building a dedicated generator per game, the shared generator loses about 4.4% in overall similarity. Lode Runner, though, did not drop at all. Note up front that this is an un-peer-reviewed preprint.

Introduction — who wrote it, and where

Today I am reading a paper called Multiverse. The authors are In-Chang Baek, Jiyun Jung, Geum-Hwan Hwang, Sung-Hyun Kim and Kyung-Joong Kim. Four of them are at the Gwangju Institute of Science and Technology (GIST); Jung is at Dongguk University.

It was posted as arXiv:2603.26782 on 25 March 2026, with a revised version on 31 March. The body is eight pages with five figures and four tables. No venue is listed, so for now I treat it as a preprint that has not passed peer review.

My reason for picking it is simple. Machinery for generating puzzle levels is usually sealed inside a single game. Examples that take the idea of "mix it with levels from another game" and make it steerable with words are still rare.

Background — text-to-level and level blending grew up apart

Start with the premise. Text-to-level generation — making a level from a written description — has become a practical entry point in the last few years. Write "stairs on the left, two enemies on the right" and you get roughly that layout. The designer never has to touch the numbers directly.

Most of that work, however, stayed inside a single game. A Mario generator makes Mario levels; a Zelda generator makes Zelda levels. Each game has its own tile set, and its own meanings for those tiles.

Separately there is a line of work called level blending. It places levels from two games into the same latent space — a shelf where a level's features are written down as numeric coordinates — and mixes those coordinates to produce something in between. Sarkar and colleagues showed this with a VAE.

But that was an operation on coordinates. You could not simply ask, in words, for "a little more Zelda." The authors' goal is to join these two lines together.

Approach — normalise the vocabulary, then widen what counts as a match

Four sources were used: Zelda, Dungeon (from the PCGRL research suite), Lode Runner and Super Mario Bros. The first two are dungeon crawlers, the last two are side-scrolling platformers. That genre split matters later.

The level data totals 5,576 maps. All are normalised to 16×16 tiles and encoded with 34 tile types. To increase the count, platformer levels were flipped horizontally and dungeon levels were rotated and flipped.

The description attached to each level was written not by a person but by a VLM — a vision-language model that can look at an image and write about it. The descriptions average 11.2 words, with a spread of 2.4. Something like "square floor room with central block cluster and surrounding wall."

Here is the first idea. Words that differ per game are swapped for shared words. A bat and a Goomba both become "enemy"; a ladder and a vine both become "climbable." Fifteen substitution rules pull the vocabulary into six buckets: enemies, environmental elements, climbable structures, collectables, interactive blocks and hazards.

The second idea is to widen what counts as a correct pairing. In ordinary contrastive learning — training that pulls correct pairs together and pushes everything else apart — each level has exactly one matching sentence. Here, if two normalised sentences are closer than 0.3, the levels count as a match even across games.

The generator that actually draws the level is a conditional VQ-VAE. It first replaces a level's features with entries from a fixed vocabulary of 256 "part numbers," then appends the text features and reconstructs the map. To blend, it either adds the two sentences' features with a weight, or writes both into a single instruction.

Findings — the dial works, but not at its ends

First, the price of sharing. Similarity here is the paper's ViTScore: a generated level and a reference level are compared as images and scored from −1 to 1. With one dedicated generator per game the scores were Dungeon 0.794, Zelda 0.767, SuperMario 0.623, Lode Runner 0.792, overall 0.744. With the shared generator: 0.728, 0.719, 0.599, 0.799, overall 0.711. The paper calls this "a modest performance drop of about 4.4% in the overall score."(Diagram) From Table I of the paper. Only Lode Runner scores slightly higher with the shared model.

Lode Runner is the eye-catching one. Against 0.792 for its dedicated generator, the shared model reaches 0.799. The other three fall; this one does not. The authors do not dwell on it, but it is worth remembering.

Now the dial itself. For same-genre pairs, moving game A's share through 0%, 25%, 50%, 75% and 100% raises similarity to A from 0.392 → 0.379 → 0.501 → 0.645 → 0.671. Similarity to B falls from 0.664 → 0.650 → 0.493 → 0.394 → 0.371. The two trade places as intended.(Diagram) From Table II of the paper (intra-genre pairs). The two lines cross at the middle.

It is not smooth, though. Going from 0% to 25% barely changes anything; the value actually slips from 0.392 to 0.379. The movement happens between 25% and 75%. The ends of the dial do little work.

How closely the ratio tracks similarity is measured as a correlation. Overall, Multiverse reaches 0.527 against 0.509 for the conventional baseline. Within the same genre it is 0.580 against 0.558, and the paper marks that difference as significant. The honest reading is that the gap itself is small.

What about blending through a single written instruction? Simply concatenating two sentences gave 48:52, and melting them into one sentence gave 49:51 — near even. Writing "based on A, featuring B" gave 58:42, and the reverse gave 37:63. The order of writing shows up directly as the mixing balance.

Where you can use this — fold your generators, widen your ideas, build a shared vocabulary

Some concrete uses. First, if you run several puzzles in parallel. A site with many daily puzzles needs a generator for each. This paper offers a rule of thumb: folding them into one costs roughly 4.4% overall.

And Lode Runner did not drop. The fewer levels a domain has, the more it may borrow from its neighbours. If you are building a new puzzle with only a handful of hand-made levels, it is worth training it alongside existing domains.

Second, as a tool for widening ideas. Set the ratio to 25% and look at what comes out — not to ship it, but to notice a combination you had not considered. As a sparring partner sitting beside a designer, a similarity of 0.5 is plenty.

Third, build a shared vocabulary for your own game. The authors' substitution table can be copied directly. Bats and slimes are both "enemies"; ladders and vines are both "climbable." Mapping those six buckets onto your own tiles gives you the foundation for ordering levels in words.

Fourth, a caution. If you ever expose the ratio dial to players or designers, remember that its ends barely act. When 0% and 25% look the same, people conclude the dial is broken. Coarser steps, or showing only the middle range, is the more honest design.

Limitations — what the authors admit, and what I noticed

Let me line up the limits. First, what the authors admit. The paper states that text-based blending shows relatively weak bias, and gives the reason: training used instructions written inside a single domain, so the model never learned compositional mixing itself.

From here on, these are points Fukai is raising. One is the measuring stick. ViTScore compares a generated level and a reference level as images. That means it only asks whether the picture sits in between. No number in this paper measures whether the result is playable or solvable.

Another is how a level is cut. Every map is normalised to 16×16 tiles. A Super Mario level is naturally much wider than that. Once cropped to 16×16, it is not a level but a slice of one. That is probably not unrelated to Mario scoring lowest of the four (0.623 dedicated / 0.599 shared).

The third is where the language came from. The descriptions were written by a VLM, not a person. An average of 11.2 words reads like machine-written length. When we say a system is "steerable with words," those words are, for now, close to machine language. Whether a human designer's vaguer instruction would work the same way is still unknown.

Fukai's reading

I would rather read this as a technique for laying a shared measuring stick across games than as a technique for making levels. The apparently naive move at its centre is putting Zelda's bat and Mario's Goomba in the same "enemy" column. The shared shelf built along the way looks more valuable than the blended levels that come off it. In the vocabulary of design criticism, this can be filed as an attempt to replace genre — a discrete category — with a continuous coordinate. This paragraph is my own reading; the authors do not write it that way.

Closing — three papers that fill in the map

If this paper alone leaves the map incomplete, I would point to some earlier work. One is Sarkar and colleagues' "Controllable Level Blending between Games using Variational Autoencoders," the starting point for mixing levels in a latent space.

Another is IPCGRL, from the same group. It generates levels with reinforcement learning while taking instructions in language, and Multiverse sits on that line. Read together, you can see what this lab has been stacking up.

And for the lineage that has a language model write the level itself, there is Todd and colleagues' "Level Generation Through Large Language Models." Same destination — from words to a level — by an entirely different road.

Sources

Papers and related material referenced in this article:

・Multiverse: Language-Conditioned Multi-Game Level Blending via Shared Representation (In-Chang Baek, Jiyun Jung, Geum-Hwan Hwang, Sung-Hyun Kim, Kyung-Joong Kim, 2026, arXiv preprint 2603.26782)

・In-Chang Baek — Google Scholar (other papers by the first author)

・Related work: Controllable Level Blending between Games using Variational Autoencoders (Anurag Sarkar, Zhihan Yang, Seth Cooper, 2020)

・Related work: IPCGRL: Language-Instructed Reinforcement Learning for Procedural Level Generation (In-Chang Baek et al., 2025)

・Related work: Level Generation Through Large Language Models (Graham Todd et al., 2023)