Unbounded: A Generative Infinite Game of Character Life Simulation

## Abstract

Abstract We introduce the concept of a generative infinite game , a video game that transcends the traditional boundaries of finite, hard-coded systems by using generative models. Inspired by James P. Carse’s distinction between finite and infinite games (Carse, 1986 ) , we leverage recent advances in generative AI to create Unbounded : a game of character life simulation that is fully encapsulated in generative models. Specifically, Unbounded draws inspiration from sandbox life simulations and allows you to interact with your autonomous virtual character in a virtual world by feeding, playing with and guiding it - with open-ended mechanics generated by an LLM, some of which can be emergent. In order to develop Unbounded , we propose technical innovations in both the LLM and visual generation domains. Specifically, we present: (1) a specialized, distilled large language model (LLM) that dynamically generates game mechanics, narratives, and character interactions in real-time, and (2) a new dynamic regional image prompt Adapter (IP-Adapter) for vision models that ensures consistent yet flexible visual generation of a character across multiple environments. We evaluate our system through both qualitative and quantitative analysis, showing significant improvements in character life simulation, user instruction following, narrative coherence, and visual consistency for both characters and the environments compared to traditional related approaches.

## 1 Introduction

In his work “Finite and Infinite Games: A Vision of Life as Play and Possibility” (Carse, ), James P. Carse introduces a distinction between two types of games. Carse defines finite games as those “played for the purpose of winning,” with boundaries, fixed rules, and a definitive endpoint. In contrast, infinite games are “played for the purpose of continuing the play,” with no fixed boundaries and evolving rules. Traditional video games are, inherently, finite games due to the limitations of programming and computer graphics. For example, game mechanics have to be fully pre-defined in the programming language and graphics assets usually have to be pre-designed (modulo traditional procedural generation which still grapples with structural limitations). This allows for only a finite, and sometimes predefined, set of actions and paths that can be taken. They also feature predefined rules, boundaries, and win conditions, which run counter to the infinite game definition.

Recent advances in generative models have been impressive. We hypothesize that these developments have finally opened up the possibility of creating the first generative infinite video game - an infinite game that is also fully subsumed in generative models with no logic or graphics being controlled by other, more traditional, processes. Two advancements have made this achievable: (1) large language models (LLMs) that can encode persistent video game mechanics (e.g. interactions with the game environment or characters, character state tracking, object permanence), generate interactive stories, and produce spontaneous, and sometimes emergent, behaviors; and (2) visual generative models capable of producing high-quality images that follow prompts. In this work, we present Unbounded, what we believe to be the first interactive generative infinite game, where all game behaviors and graphics are generated by AI models, transcending the constraints of hard-coded systems. Unbounded draws inspiration from sandbox life simulations and digital pet games such as Little Computer People, The Sims and Tamagotchi. It incorporates elements from tabletop roleplaying games like Dungeons & Dragons, which offer unconstrained storytelling experiences that have been unattainable in video games.

Some useful prior work has proposed ideas that are related to our concept of generative infinite games. Gaudl et al. () proposes fluidic games that merge gameplay with game design, automated game design (Cook et al., ) explores automated systems that can help in making new games, and work on AI-based games (Treanor et al., ) proposes design techniques for games that put AI at the forefront of user experience. These concepts are different from our definition of generative infinite games since they emphasize structured exploration within predefined game parameters and tools, where the design space is extensive yet ultimately bounded. In contrast, infinite games, as we envision them, aim to continuously evolve beyond predefined structures, with generative models dynamically creating both content and mechanics in real-time, enabling an open-ended gameplay experience with no fixed endpoint or limitations on possible interactions. There is also important work on using machine learning models as components that generate parts of a game. Agarwal () generates novel interactions, Sun et al. () generates new mechanics and items as well as some graphical assets, and there is also work on orchestration of different models for game design (Liapis et al., ). These works do not generate all components of the game. In contrast, in our work, all of the game mechanics, characters, environments, narrative, and graphics are fully produced by generative models. This is more similar in spirit to recent work Genie (Bruce et al., ) and GameNGen (Valevski et al., ), although in contrast to these works that mainly generate platformers with diffuse mechanics or regenerate behaviors of one pre-existing game, our work proposes an open-ended narrative experience with stable game mechanics enabled by an LLM-based game engine.

Unbounded offers a gameplay loop centered around character simulation and open-ended interaction (Figure 2). Players can insert their characters into the game, defining their appearance and personality. The game generates a world where these characters can explore environments, interact with objects, and engage in conversations. The game generates new scenarios, stories, and challenges based on the player’s actions and choices, creating a personalized and infinite gaming experience. Some generative game examples are shown in Figure 3.

Specifically, Unbounded has the following capabilities: (1) Character Personalization: players can insert their characters into the game, defining their appearance and personality. (2) Game Environment Generation: Unbounded generates a persistent world that the characters can explore and interact. (3) Open-Ended Interaction: Players can interact with the character using natural language instructions, and there are no pre-defined rules to constraint the interaction. (4) Real-Time Generation: we pay special attention to the speed of the game and achieve 5-10x speedups over a naive implementation, serving each new scene with a latency of about one second.

Our approach introduces technical innovations in both LLM and vision generation domains. On the language side, we developed a LLM based game engine capable of maintaining consistent game mechanics, generating coherent narratives, and producing contextual character responses in real-time. Our distilled specialized model is fine-tuned on data automatically generated with two collaborative strong LLM agents, without the need for human annotation in the loop. Our distilled LLM model handles the dynamic generation of game rules and scenarios, adapting to player input and game state. In visual generation, we introduce a new regional IP-Adapter, which allows for the consistent generation of characters and environments while maintaining visual coherence across multiple images. Specifically, our regional IP-Adapter conditions the image generation on the game environment and character appearance encoded modulated by a dynamic mask obtained from attention outputs in cross-attention layers. This is in order to mitigate the interference between the environment and character, in order to have both reliably appear in the scene. This approach enables real-time image generation that reflects the game state and player actions.

The contributions of this work are conceptual and technical. We introduce the notion of a generative infinite game, demonstrating its feasibility and potential impact on the future of interactive entertainment. We present a new paradigm for game design where the game logic and content are encapsulated within generative models. Our main technical contributions include the specialized distilled LLM for game logic and narrative generation and the regional IP-Adapter for consistent visual generation. We demonstrate the effectiveness of our regional IP-Adapter through both quantitative and qualitative evaluations, surpassing state-of-the-art in both character and environment consistency. Furthermore, we show that our distilled LLM performs comparably to a very large LLM while having interactive speed. These advancements enable the creation of Unbounded and lay the groundwork for future research and development in the field of AI-driven interactive experiences.

Figure: Figure 2: Example of Unbounded. Based on an initial user input, Unbounded sets up game simulation environments, and generates character actions in the environments. Users can interact with the character with natural language instructions, exploring the game with unlimited options.
Refer to caption: x2.png

## 2 Related Work

##### Controllable Text-to-Image Generation.

Controllable text-to-image generation becomes a key research direction in diffusion model applications, enabling diverse ways to guide the generation process. For instance, ControlNet (Zhang et al., ) introduces conditioning mechanisms that utilize control signals such as depth maps, poses, edges, and segmentation maps to guide image generation. Other works focus on layout control using bounding boxes to control object placement within the generated images (Li et al., ; Shin et al., ). Beyond these control signals, another major area of research involves personalization, where the goal is to generate consistent characters (Ruiz et al., ; Gal et al., ; Kumari et al., ; Avrahami et al., ) or consistent face identities (Li et al., ; Wang et al., ; Yan et al., ; Ruiz et al., ) across multiple generations. However, most existing approaches lack support for conditioning both characters and environments separately, often requiring predefined masks for generating characters (Chen et al., ; Lugmayr et al., ; Yang et al., ), with the environment remaining identical to the input image. This limitation makes it difficult to seamlessly integrate characters into different environments while ensuring both consistency and alignment with the input prompts.
IP-Adapter (Ye et al., ) tackles this task by conditioning the generation on the environment and character images. However, IP-Adapter tends to over reconstruct the conditions, which causes interference between them. In this paper, we build our approach on IP-Adapter and propose an improved regional IP-Adapter with block drop, separating character and environment generation to enhance consistency.

##### Large Language Models in Image Generation.

Large language models have demonstrated strong in-context learning capability (Brown, ), which enables them to solve diverse customized tasks based on human instructions and in-context examples. In the field of image generation, large language models have been employed for various tasks, such as image layout generator based on prompts (Cheng et al., ; ), interactive multi-turn image generation (Zeqiang et al., ; Huang et al., ; Gong et al., ; Wang et al., ), and interleaved text and image generator (Team, ; Zhou et al., ). Unlike these applications, our work focuses on distilling a specialized LLM, serving as a game engine, responsible for generating game mechanics, narratives and character interactions.

##### Game Generation.

In the field of Procedural Content Generation (PCG), diverse approaches have been explored to create dynamic game content (Summerville et al., ).
Early works employed concept maps (Treanor et al., ), Markov Chains (Snodgrass & Ontañón, ), Bayes Nets (Guzdial & Riedl, ), and LSTMs (Summerville & Mateas, ) to simulate interactive game environments.
Recent research has advanced to using Generative Adversarial Networks (GANs) for generating game levels or dynamic environments (Volz et al., ; Kumaran et al., ; Schubert et al., ; Kim et al., ), exploiting the use of diffusion models for game generation (Zhou et al., ), utilizing LLMs to design and generate the game environments or mechanics (Sudhakaran et al., ; Todd et al., ; Nasir & Togelius, ; Hu et al., ; Zala et al., ; Anjum et al., ; Chung & Kreminski, ; Chung et al., ) and employing LLMs to generate items and narratives, as well as using diffusion models for scene generation in 1001 Nights (Sun et al., ).
One major feature of this body of work is that AI is often employed to help in game design, or to generate one component of the game, for example environments or interactions. Our work aims to fully generate all behaviors of the game, including all the game’s graphics, characters, environments, and narrative, using generative models.

Bruce et al. () explore synthesizing a completely new interactive game with a video diffusion model conditioned on previous game frames and user actions. This work achieves impressive initial results for this direction, at present it has limitations on the scope of the games being generated, with mostly 2D platformers being represented. This differs from our work since these are not infinite games. We also believe that generating compelling infinite games by only modeling pixels is a hard problem and hence we opt to use language models to generate all the open-ended game mechanics instead. Valevski et al. () train a diffusion model to be a game engine running Doom, and achieve consistent generation of game mechanics by only modeling pixels. Nevertheless, this work currently fits the diffusion model to a single finite game that already exists.

Besides generating the game content, there has been exploration in letting AI take different roles (e.g., competitor, designer, or teammate) in games (Zhu et al., ; Gallotta et al., ; Pell, ; Agarwal et al., ), and a system with continuous creativity for automated game design for games that are played on a grid of up to 8x8 squares is built in  Cook ().
Alongside generating visual game environments, another line of research builds narrative text games with conditional language generation models to complete a knowledge graph (Ammanabrolu et al., ) or utilizes LLMs or other AI tools to generate the game (Li et al., ; Latitude Inc., ; Wang et al., ) or act in different roles in the game (Zhu et al., ; Kreminski et al., ; Cui et al., ; Zhou et al., ; Dambekodi et al., ). Our work diverges from these by (1) tackling both generation of all game mechanics, graphics, characters, environments, and narrative of the game using generative models (2) introducing personalization into generative games, where a user can insert a custom character and personalize the game world and initial story arc, and (3) achieving interactive real-time refresh speed through our innovations in the vision and language domains.

Figure: Figure 3: Generative game examples of Unbounded. The user can insert a custom character into the game, engage with the character through natural language instructions, bring the character to different environments, and interact with it to maintain a healthy state under the games’ mechanics.
Refer to caption: x3.png

## 3 Method

We introduce Unbounded, an interactive generative infinite game powered by text-to-image generation models and large language models. Unbounded offers: (1) Custom Character Personalization: users create unique characters with customizable appearances and personalities; (2) Dynamic World Creation: the system generates a persistent, interactive game world for exploration; (3) Open-Ended Interaction and Gameplay: players interact with their characters via natural language, with the game dynamically generating new scenarios and storylines based on player actions; and (4) Generation in Interactive Speed: the game runs with near real-time interactivity, achieving a refresh rate close to one second. We detail the methods enabling these capabilities in this section.

### 3.1 Personalization of Latent Consistency Models for Character Consistency

A key feature of Unbounded is its ability to serve a fully generative model-based game with real-time interaction. This is made possible through the use of latent consistency models (LCM) (Luo et al., ) which allow for high-resolution image generation with as few as two diffusion steps. By utilizing LCMs, Unbounded achieves real-time text-to-image (T2I) generation, critical for delivering an interactive gaming experience with a refresh rate close to one second.

To support the use of custom characters in the game, we incorporate DreamBooth (Ruiz et al., ) into the T2I model. Given a set of character images, we fine-tune the diffusion model using LoRA modules (Hu et al., ). During fine-tuning, we append a unique identifier, “[V]”, which has a weak prior in the model, to denote the subject. DreamBooth personalization is performed on the base diffusion model, and we merge the subject-specific LoRA with the LCM LoRA trained for few-step diffusion. This simple arithmetic LoRA merging works surprisingly well in maintaining both inference speed and subject preservation. Other alternatives for personalization exist, and many do not need setup time, yet we find that they often fail in strongly preserving the character’s features, which is a critical component in order to have a satisfactory experience in this type of game.

Figure: Figure 4: (a) Our overall image generation method. We achieve real-time image generation with LCM LoRA, maintain character consistency with DreamBooth LoRAs, and introduce a regional IP-Adapter (shown in (c)) for improved environment and character consistency. (b) Our proposed dynamic mask genreation separating the environment and character conditioning, preventing interference between the two.
Refer to caption: x4.png

### 3.2 Regional IP-Adapter with Block Drop for Environment Consistency

Another key feature of Unbounded is generating the character in pre-defined environments performing different actions based on user instructions. Thus, maintaining both character and environment consistency is essential. While character consistency is handled as discussed in Sec. 3.1, two additional challenges arise: ensuring the environment consistency across different generations and accurately placing the character within the environment, without losing alignment with text prompts. We find that existing method fails to consistently perform well for all requirements in interactive speed. As one of our main technical contributions we propose a novel regional IP-Adapter in order to consistently implant a character in pre-defined environments following text prompt.

#### 3.2.1 Regional IP-Adapter

We propose an improved version of IP-Adapters (Ye et al., ) that enables dual-conditioning on both subjects and environments, allowing for the generation of a pre-defined character in a user-specified environment. Unlike the original IP-Adapters, which focus on single-image conditioning, our approach introduces dual-conditioning and dynamic regional injection mechanism to represent both concepts simultaneously in the generated images.

Let us start with an example. As shown in Figure 4, given the text prompt “Beneath the desert sky, [V] witch coaxes the cacti to blossom with vibrant, glowing flowers” and the desert environment image, the model needs to know that the character should be generated beside cacti and within the desert environment. This requires the model to correctly (1) preserve the environment (2) preserve the character (3) follow the prompt. Utilizing IP-Adapter to encode the environment greatly harms both (2) and (3) (Figure 8). Our regional IP-Adapter solves this by implementing a novel attention separation mechanism for generating the two elements. Specifically, we introduce a dynamic mask-based approach that leverages cross-attentions between the character text embedding and the hidden states at each layer of the model. As shown in Figure 4, our approach applies the adapter to the regions corresponding to the environment and character separately, preventing the environment conditioning to interfere with the character’s appearance, and vice versa. At each cross-attention layer, we calculate the attention map between a pre-defined character text embedding $K_{c}$ and the output hidden states from the text cross-attention layer $O_{t}$:

$$ $A_{c}=\frac{W_{q}O_{t}*W_{k}K_{c}^{T}}{\sqrt{d}}$ (1) $$

where $W_{q}$ and $W_{k}$ are projection weights adopted from the text cross-attention layers. The dynamic mask we use for the regional IP-Adapter is defined as:

$$ $M_{c}=\left\{\begin{array}[]{ll}1&A_{c}\leq threshold\\ 0&A_{c}>threshold\\ \end{array}\right.$ (2) $$

We rank the attention scores $A_{c}$ and set the $threshold$ at top $r\%$, dynamically updating the mask at each attention layer throughout the diffusion process.
The output of the cross-attention blocks is calculated as:

$$ $O=O_{t}+\alpha_{e}M_{c}*O_{e}+\alpha_{c}(1-M_{c})*O_{c}$ (3) $$

where $O_{e}$ and $O_{c}$ represent the outputs of the IP-Adapter image cross-attention layers of environment and character, and $\alpha_{e}$ and $\alpha_{c}$ are the IP-Adapter scales to adjust the strength of the environment and character conditioning respectively. Our regional IP-Adapter with dynamic masks allows the model to generate the character without the interference from the environment conditioning, greatly enhancing character consistency preservation (Figure 8). Besides, it preserves environment consistency by generating the background around the character conditioning on the environment image, while maintaining the implicit layout information in the hidden states from the text cross-attention layers $O_{t}$, ensuring the character is placed accurately following the text prompt.

Figure: Figure 5: Attention map between character embedding and hidden states in cross-attention layers in different blocks. The character embedding we use is “A [V] witch”.
Refer to caption: x5.png

#### 3.2.2 Block-Wise Drop on Environment Conditioning

For our regional IP-Adapter, we use a dynamic mask from the cross-attention between character text and hidden states. This mask’s quality is key for separating character and environment generation. Figure 5 shows attention maps between character embeddings and hidden states in cross-attention layers of down sample blocks. We observe that the attention doesn’t focus on the character but spreads across the full image for these blocks. We take this as a strong indication that the diffusion model doesn’t separate character and environment generation in these layers and instead focuses on overall image structure based on text prompts. This aligns with Wang et al. ()’s finding that down sample blocks capture spatial layouts more, while up sample blocks capture style. We drop the regional IP-Adapter in down sample blocks, using it only in mid and up sample blocks. This allows for better spatial layout generation between character and environment.
Additionally, we find that adding dynamic regional IP-Adapters in up sample blocks more strongly aligns the generated background with the conditioning environment by extracting relevant semantic information while preserving character-specific details like appearance and poses.

### 3.3 Language Model Game Engine with Open Ended Interactions and Integrated Game Mechanics

Unbounded simulates character actions in pre-defined environments with images generated based on scene text descriptions while monitoring the character’s state and providing the user with natural language interaction with the character and game environment. For example, the user can take the character to different environments, interact with the character (e.g. “I pet the character on its head”), or essentially take any open ended action e.g. “I pet the character and then take them for a rocket ride at the space station.”. Since the game is ultimately built on a language model, these expansive capabilities present several challenges: (1) Environment Binding: the model needs to place the character in the correct environment based on the natural language instructions. (2) Coherent Story Generation: the model generates coherent narrative descriptions and character responses that align with user-specified character traits. (3) Game Mechanics Generation: the model needs to monitor the state of the character (i.e., hunger, energy, fun, hygiene), and update them based on user interactions and story events. (4) Prompt Rewriting: the model needs to rewrite the narratives for the diffusion model (i.e., append special token “[V]” for the character, align environment descriptions to the pre-generated environments for better environment consistency).

Surprisingly, we find that a very large language model (e.g., GPT-4, GPT-4o) with detailed instructions and using in-context learning (Brown, ) can exhibit these capabilities. Nevertheless, using such large models as game engines is not directly feasible due to the large latency (e.g., 5 seconds for a 7B model to give one response). Given this, we propose to distill these capabilities from a very large model into a smaller model based on Gemma-2B (Team et al., ) for game logic and narrative generation that supports real-time interaction. In this section we propose two key technical contributions (1) a design for a character life simulation game using two very large language models that control for world modeling and user interaction respectively (2) a framework for distilling this knowledge into one smaller language model that is fast enough to achieve interactive speeds.

#### 3.3.1 Character Life Simulation with Multi-LLM Collaboration

We build a character life simulation game with two LLMs agents. One agent serves as the world simulation model, responsible for setting up game environments, generating narratives and image descriptions, tracking character states and simulating the character’s behavior. The second agent functions as a user model, simulating the player’s interactions with the world simulation model. It has three types of interactions: continuing the story within the current environment, moving the character into different environments, or interacting with the character to maintain the healthy state of the character. In each interaction category, the user has the option to provide personality details of the character or guide the character actions that, in turn, guide the simulator’s narrative generation. This interaction between the world simulation LLM and the user LLM allows for a dynamic character life simulation game with virtually unlimited interaction possibilities and narrative paths.

Figure: Figure 6: Overview of our user-simulation data collection process for LLM distillation. (a) We begin by collecting diverse topic and character data, filtered using ROUGE-L for diversity. (b) The World LLM and User LLM interact to generate user-simulation data through multi-round exchanges.
Refer to caption: x6.png

#### 3.3.2 Framework for Small LLM Distillation

We propose a framework for distilling the capabilities of larger LLMs into the smaller, more efficient model using synthetic data generated by the multiple stronger LLMs. Our framework contains two steps: (1) automated data collection (Figure 6) and (2) small model distillation.

##### Automated Data Collection

Our goal is to build a general-purpose character life simulator capable of understanding a wide range of character traits and generating games across diverse topics. To achieve this, the first step is to gather a diverse dataset of topics and characters. We prompt a large LLM to generate pairs of topics and corresponding main characters. To ensure data diversity, we retain only the generated pairs whose ROUGE-L similarity to existing data is below 0.7, following (Wang et al., ), which demonstrated the importance of diverse data for enhancing an LLM’s ability to follow instructions. This process results in 5,000 unique topic-character pairs, which serve as the basis for user-simulator interaction data.

In the second step, we collect multi-round interaction data between the world simulation LLM and the user LLM. The process begins with the world simulation LLM setting up the game environment and initiating a character action based on a randomly sampled topic-character pair from the dataset. The user LLM is then prompted to provide interaction inputs, while the world simulation LLM generates updated character actions, states, and responses. This iterative process continues for five interaction rounds per session, resulting in a total of 5,000 user-simulator interaction examples. All the prompt templates are in Appendix.

##### Distillation

Once the interaction data has been collected, we fine-tune the smaller Gemma-2B model using the 5,000 synthetic user-simulator interaction samples. During supervised fine-tuning, we mask out the loss on user input data, focusing the optimization on learning the world simulation model’s behavior based on multi-round interaction history and current user input. This approach enables Gemma-2B to replicate the capabilities of larger LLMs as a game engine while supporting real-time interaction. Our distilled Gemma-2B demonstrates performance comparable to GPT-4o, effectively following user input and supporting unbounded interactions.

## 4 Experimental Setup

### 4.1 Evaluation Benchmarks

##### Evaluation of Image Generations

To evaluate our image generation approach, we collect an evaluation dataset consisting of 5,000 (character image, environment description, text prompt) triplets with GPT4o (OpenAI, ). It includes 5 characters (dog, cat, panda, witch, and wizard), 100 diverse environments, and 1,000 text prompts (10 per environment). We evaluate the image generation performance under three criteria: environment consistency, character consistency and semantic alignment with the text prompt. To measure similarity between images, we employ CLIP-I (Radford et al., ), DINO (Caron et al., ), and DreamSim (Fu et al., ). We denote the similarity between environment reference image and the generated images as CLIP-I^E, DINO^E, DreamSim^E, and the similarity between the character reference image and the generated images as CLIP-I^C, DINO^C, DreamSim^C. Additionally, we use CLIP-T (Radford et al., ) to evaluate the semantic alignment with the text prompt. Given that Unbounded is a character life simulation game, ensuring the presence of the character in the image is important. Therefore, we further utilize Grounding-DINO (Liu et al., ) to detect the presence of the character in the generated images. We set similarity scores to 0 and distance scores to 1 if there is no character in the generated image.

##### Evaluation of LLM Generations

We collect an additional evaluation dataset with 100 user-simulator interaction samples using the pipeline in Sec.
3.3. Each user-simulator interaction sample contains five rounds of interaction between the user and the world model. We use GPT-4 (OpenAI, ) as a judge, scoring the response between two models (baseline model vs. our model) in overall score, and then in four aspects: accuracy of character state update, environment relevance, story coherence, and user input instruction following. Scores range from 0 to 10.

### 4.2 Implementation Details

Our image generator is built on SDXL (Podell et al., ).
We train a DreamBooth LoRA of rank 16 with batch size 1 and a constant learning rate 1e-4 for 500 steps on a single A100, which takes approximately 30 mins. The special token we append before the character is “sks”. During inference, we merge the LCM-LoRA with DreamBooth LoRA with scale 1.0 for each. We use IP-Adapter-plus-sdxl-vit-h for encoding the environment, and IP-Adapter-plus-face-sdxl-vit-h for encoding the character. The dynamic mask ratio $r\%$ in set to be 60%.

Our LLM is built on Gemma-2B (Team et al., ). We distill the LLM using 5,000 user-simulator interaction samples collected from GPT-4o. We train the LLM for 6,500 steps, with batch size 8, distributed across 4 A100s, and learning rate 1e-4. The learning rate scheduler is set to be cosine annealing (Loshchilov & Hutter, ), and the warmup steps ratio is 0.03. In evaluation, we use an LLM to generate responses with sampling. The sampling hyperparameters are set to be default.

## 5 Results and Analysis

**Table 1: Comparison of Unbounded and other methods for maintaining environment consistency and character consistency. Unbounded achieves the best performance in maintaining consistency, while maintaining comparable semantic alignment with the text prompt. Best scores are in bold.**
| Methods | Environment Consistency | Character Consistency | Semantic Alignment |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| CLIP-I^E $\uparrow$ | DINO^E $\uparrow$ | DreamSim^E $\downarrow$ | CLIP-I^C $\uparrow$ | DINO^C $\uparrow$ | DreamSim^C $\downarrow$ | CLIP-T $\uparrow$ |  |
| IP-Adapter (Ye et al., ) | 0.470 | 0.381 | 0.595 | 0.366 | 0.139 | 0.832 | 0.168 |
| IP-Adapter-Instruct (Rowles et al., ) | 0.334 | 0.151 | 0.832 | 0.246 | 0.124 | 0.872 | 0.098 |
| StoryDiffusion (Zhou et al., ) | 0.528 | 0.257 | 0.733 | 0.629 | 0.464 | 0.545 | 0.242 |
| Ours | 0.563 | 0.322 | 0.675 | 0.676 | 0.470 | 0.488 | 0.242 |

Figure: Figure 7: Comparison with other approaches for generating environment and character consistent images based on text prompts. We observe that our method strongly outperfoms related work.
Refer to caption: x7.png

**Table 2: Ablations of the effectiveness of dynamic regional IP-Adapter and block drop in our consistent image generation approach.**
| No. | Block | Regional | Scale | Environment Consistency | Character Consistency | Alignment |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Drop | IP-Adapter | CLIP-I^E $\uparrow$ | DINO^E $\uparrow$ | DreamSim^E $\downarrow$ | CLIP-I^C $\uparrow$ | DINO^C $\uparrow$ | DreamSim^C $\downarrow$ | CLIP-T $\uparrow$ |  |  |
| 1. | ✗ | ✗ | 1.0 | 0.123 | 0.111 | 0.885 | 0.073 | 0.024 | 0.973 | 0.034 |
| 2. | ✓ | ✗ | 1.0 | 0.414 | 0.331 | 0.647 | 0.337 | 0.147 | 0.832 | 0.149 |
| 3. | ✓ | ✓ | 1.0 | 0.563 | 0.322 | 0.675 | 0.676 | 0.470 | 0.488 | 0.242 |
| 4. | ✗ | ✗ | 0.5 | 0.470 | 0.381 | 0.595 | 0.366 | 0.139 | 0.832 | 0.168 |
| 5. | ✓ | ✗ | 0.5 | 0.577 | 0.332 | 0.640 | 0.627 | 0.374 | 0.575 | 0.252 |
| 6. | ✓ | ✓ | 0.5 | 0.549 | 0.263 | 0.726 | 0.705 | 0.514 | 0.450 | 0.246 |

### 5.1 Comparison with Different Approaches for Maintaining Environment Consistency and Character Consistency

Quantitative Results We compare our regional IP-Adapter with block drop with previous approaches in maintaining environment consistency and character consistency. For all the approaches, we merge the character LoRA and LCM LoRA with the model to support fast inference and improve character consistency and provide an apples-to-apples comparison.
As shown in Table 1, our approach consistently outperforms previous approach in maintaining environment consistency and character consistency, while achieving comparable performance in maintaining semantic alignment. Specifically, our approach significantly overtakes StoryDiffusion (Zhou et al., ) by 0.047 in CLIP-I^C, and 0.057 in DreamSim^C for character consistency, and 0.035 in CLIP-I^E, 0.065 in DINO^E, and 0.058 in DreamSim^E for environment consistency, demonstrating the effectiveness of our approach. Besides, our approach also achieves comparable performance in maintaining semantic alignment, suggesting strong text following capabilities.

Qualitative Results
We present a qualitative comparison with other approaches in Figure 7. Our regional IP-Adapter with block drop consistently generates images with high character consistency, whereas other methods may fail to include the character or generate characters with inconsistent appearances (see Example 1 & 2). Furthermore, we show that our approach balances environment consistency and character consistency well, while other approaches might generate environments that differ from the condition environment (e.g., StoryDiffusion in Example 1 & 3).

Figure: Figure 8: Comparison between our regional IP-Adapter approach and baseline approaches.
Refer to caption: x8.png

### 5.2 Effectiveness of Dynamic Regional IP-Adapter with Block Drop

Quantitative Results We demonstrate that our regional IP-Adapter with block drop is essential for placing the character in the environments following the text prompt, while maintaining both environment and character consistency with ablation studies. As shown in Table 2, adding block drop improves both environment and character consistency compared with multi-IP-Adapter (No. 2. vs. No. 1.), with an increase of 0.291 in CLIP-I^E and 0.264 in CLIP-I^C, alongside better alignment between the text prompt and the generated image. Furthermore, our regional IP-Adapter enhances character consistency and text alignment while maintaining comparable performance in environment consistency (No. 3 vs. No. 2). We also explore the effect of the environment IP-Adapter scale, and our findings indicate that using a smaller scale (e.g., 0.5) generally improves character consistency, though it slightly compromises environment consistency (No. 6 vs. No. 3).

Qualitative Results As shown in Figure 8, conditioning on the environment using IP-Adapter achieves good environment reconstruction, but the character consistency is influenced by the environment style. Introducing block drop improves adherence to the text prompt, resulting in images with the correct spatial layout for both the character and the environment. However, the character’s appearance remains influenced by the surrounding environment. By incorporating our proposed regional injection mechanism with our proposed dynamic mask scheme, the generated images achieve strong character consistency while maintaining effective conditioning on the environment.

**Table 3: Comparison of Unbounded and different LLMs on serving as game engines for open ended interactions and integrated game mechanics. We use GPT-4 to provide pairwise scores between our model and other LLMs.**
| Model | Overall | State | Environment | Story | Instruction |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Update | Relevance | Coherence | Following |  |  |  |  |  |  |  |
|  | Base | Ours | Base | Ours | Base | Ours | Base | Ours | Base | Ours |
| Gemma-2B (Team et al., ) | 6.22 | 7.44 | 5.60 | 7.47 | 6.12 | 7.94 | 6.34 | 7.57 | 6.43 | 7.67 |
| Gemma-7B (Team et al., ) | 6.80 | 7.39 | 6.29 | 7.43 | 7.07 | 7.91 | 6.90 | 7.48 | 6.89 | 7.53 |
| Llama3.2-3B (Meta, ) | 7.21 | 7.50 | 6.86 | 7.38 | 7.63 | 7.93 | 7.36 | 7.56 | 7.31 | 7.67 |
| Ours-1k | 7.65 | 7.82 | 7.50 | 7.74 | 8.10 | 8.19 | 7.78 | 7.93 | 7.82 | 7.97 |
| GPT-4o (OpenAI, ) | 7.76 | 7.68 | 7.69 | 7.66 | 8.20 | 8.10 | 7.95 | 7.82 | 7.85 | 7.82 |

### 5.3 Effectiveness of Distilling Specialized Large Language Model

We show that our diverse user-simulator interaction data effectively distills Gemma-2B into a capable game engine. As shown in Table 3, zero-shot inference with small LLMs (i.e., Gemma-2B, Llama3.2-3B), or a slightly larger LLM (i.e., Gemma-7B) results in lower performance compared to ours, highlighting the importance of distillation from a stronger LLM for game world and character action simulation. Furthermore, we show that our model achieves performance comparable to GPT-4o, validating the effectiveness of our approach. We also investigate the impact of distillation data size on performance by comparing a Gemma-2B model distilled with 1K data and 5K data. Results show that using a larger dataset consistently improves performance across all aspects, highlighting the potential for further enhancements with more data to fully match GPT-4o’s performance.

## 6 Conclusion

We introduce Unbounded, an interactive generative infinite game based on generative models. Unbounded is built on two main components, a specialized, distilled LLM for real-time interaction, and a fast diffusion model with our proposed regional IP-Adapter for consistent generation across multiple scenes. We show that our proposed approach allows for an interactive game subsumed in generative models, with consistent characters, environments and story and an expansive gameplay characteristic of an infinite game.

## Acknowledgments

We thank Shiran Zada, Peyman Millanfar, Shlomi Fruchter, Michael Goin and Matthew Guzdial for the thoughtful feedback and discussion.

## Appendix

In this appendix, we present the following:

- •
Prompts we use for user-simulation data collection in Sec. A.
- •
Evaluation prompts we use for querying GPT-4 as a judge for LLM evaluation in Sec. B.
- •
Reproducibility statement in Sec. C.

## Appendix A Prompt for synthetic user-simulator interaction data collection

In this section, we provide the prompt templates we use to collect the user-simulation data. Specifically, we query GPT-3.5 to generate diverse topics and character descriptions using the template shown in Figure 9. The prompt template for guiding the potential user interactions for user LLM is shown in Figure 10. To ensure user interactions align with the dialogue history, we include the interaction history as input to the user LLM. The world simulation LLM prompt template, shown in Figure 11, also takes in the dialogue history and generates the next character actions, states and narratives. We constraint the world simulation LLM to generate one storyline at a time, allowing users to choose how to continue the story.

## Appendix B Evaluation Prompt

We include the prompt template we use to compare the outputs from two LLMs in Figure 12. The prompt is adapted from Vicuna (Chiang et al., ), and has been validated as an effective tool for comparing the performance of two LLMs on a given task.

## Appendix C Reproducibility Statement

First, we include the implementation details of Unbounded in Sec. 4.2, covering the training hyperparameters for Dreambooth fine-tuning, and LLM distillation, and the hyperparameters we use during inference for both LLM and image generation. Second, we provide detailed description of the user-simulation data we collect for training in Sec. 3.3, and further include the prompt template used to query GPT models in Appendix Sec. A. Lastly, for the LLM-based evaluation, the prompt template for querying GPT-4 to compare two LLM outputs is provided in Appendix Sec. B.

Figure: Figure 9: Prompt template used to collect diverse topic and character data.
Refer to caption: x9.png

Figure: Figure 10: Prompt template used to query user LLM.
Refer to caption: x10.png

Figure: Figure 11: Prompt template used to query world simulation LLM.
Refer to caption: x11.png

Figure: Figure 12: Prompt template used to query GPT4 to compare the performance between two LLM outputs. The prompt is adapted from Vicuna (Chiang et al., ).
Refer to caption: x12.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. How do the authors position their work in the field of technical game design? 
2. What do longer gameplay examples look like? 
3. How do the authors respond to my concerns around their "Evaluation of LLM Generations"?
soundness: 2
strengths: The main strengths of the paper are (1) the originality of entirely basing a virtual pet game on LLMs, (2) the significance of the two primary technical contributions to figure coherent image generation and real time LLM application uses, and (3) the quality of the image portion of the evaluation/experiments. The paper is also overall well-written, especially in terms of the technical aspects. These primarily justify the positive aspects of my above scores.
summary: The authors present "UNBOUNDED" a virtual pet game based on LLMs. The authors present two novel technical elements to support this game: a regional IP-Adapter for character-environment consistency and a domain-specific distillation approach for finetuning a smaller LLM to allow for real time gameplay. The authors then present experiments comparing their approach to baselines in terms of visual quality and consistency, and overall game quality as scored by GPT-4o.
weaknesses: The paper has two major weaknesses in its present draft, the way it positions itself in terms of prior work and the evaluation. 

### Prior Work

The authors do not appear to have engaged with the field of technical games research at all. This is a shame, as their game can be understood as an AI-based game [1] or specifically a NN game [2]. More broadly, the authors' work in terms of generation would fit into the Procedural Content Generation paradigm [3]. There is a 3+ decades long history of work in this space that is relevant to the authors' work [4], with significant recent work at the intersection of LLMs and game generation [5], and it is crucial that the authors update the introduction and related work to situate their work within this field.

### Evaluation

The authors primarily evaluate their work in terms of image quality and I have no major concern with these results (though the DreamSim results seem to incorrectly attribute the best score to their system). However, I have major concerns with the "Evaluation of LLM Generations", which is functionally the closest thing presented to a holistic evaluation of UNBOUNDED. Firstly, the norm within the area would be to make use of a user study for evaluation purposes [6,7]. Particularly since the authors make such an effort to allow for real time control, this would seem to follow naturally. Secondly, the evaluation is somewhat concerning due to the training process. Specifically, since the distillation approach makes use of GPT-4 to simulate user interaction data and the authors sample for uniqueness/variety, its fairly likely that the newly sampled user interaction data approximations will be very similar to these. Further, the largest model the authors compare to is again a GPT-4 variant. Given that GPT-4 is being used for both generation of data, as the system, and as the evaluation, there's a clear risk for bias. This could be addressed by any number of ways, including automated metrics for measuring game quality developed in prior game generation-like work [8,9]. But at present, it is difficult as an outside reader to get a sense of the actual quality of UNBOUNDED as a game. Failing this, it might be beneficial to include longer examples of gameplay in the supplementary materials at least.

### Figures

While these are not of major concern, I wanted to note two aspects of figures that I felt could be improved. First, the authors make use of a large number of fonts in their figures, and their primary font is a bit difficult to read. I'd suggest updating the figures to use a single, more legible font. Second, Figure 4 is largely superfluous. If the authors wish to retain it, it might be a better fit for an appendix.

1. Treanor, M., Zook, A., Eladhari, M. P., Togelius, J., Smith, G., Cook, M., ... & Smith, A. (2015). AI-based game design patterns.
2. Zhu, J., Villareale, J., Javvaji, N., Risi, S., Löwe, M., Weigelt, R., & Harteveld, C. (2021, May). Player-AI interaction: What neural network games reveal about AI as play. In Proceedings of the 2021 CHI Conference on Human Factors in Computing Systems (pp. 1-17).
3. Shaker, N., Togelius, J., & Nelson, M. J. (2016). Procedural content generation in games.
4. Pell, B. (1992). METAGAME: A new challenge for games and learning.
5. Gallotta, R., Todd, G., Zammit, M., Earle, S., Liapis, A., Togelius, J., & Yannakakis, G. N. (2024). Large language models and games: A survey and roadmap. arXiv preprint arXiv:2402.18659.
6. Anjum, A., Li, Y., Law, N., Charity, M., & Togelius, J. (2024, May). The Ink Splotch Effect: A case study on ChatGPT as a co-creative game designer. In Proceedings of the 19th International Conference on the Foundations of Digital Games (pp. 1-15).
7. Guzdial, M., & Riedl, M. O. (2021). Conceptual game expansion. IEEE Transactions on Games, 14(1), 93-106.
8. Khalifa, A., Green, M. C., Perez-Liebana, D., & Togelius, J. (2017, August). General video game rule generation. In 2017 IEEE Conference on Computational Intelligence and Games (CIG) (pp. 170-177). IEEE.
9. Guzdial, M., & Riedl, M. (2018, September). Automated game design via conceptual expansion. In Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment (Vol. 14, No. 1, pp. 31-37).

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: To which extent are results from Figure 6 consistent with results from Table I?
How have you ensured the quality and fairness (for evaluation) of the text prompts sample?
How can the current approach maintain narrative consistency over a number of interactions?
soundness: 3
strengths: This is an ambitious piece of work, tackling difficult technical issues in balancing generation and interaction, as well as various training and fine-tuning protocols. It appears to have innovated on a number of aspects, for instance the dynamic mask to balance character and environment generation. It gives some interesting, detailed, insights such as those of Figure 4. The improvement over IP-Adapter thus appears more than incremental. Another strong points is the Small LLM distillation framework.
The comparative LLM evaluation has staged an appropriate number of LLM, capturing size and diversity. 
Finally, the paper demonstrates a good command of recent relevant work and compares its approach to really recent alternative methods (2023, 2024), which is welcome.
Having considered the authors' rebuttal and additional data, I have raised my score for contribution to 3 ('good').
summary: This work combines various aspects of Generative AI to develop a LLM-based game engine. The design principles refer to open-world, continuous interaction games with limited simultaneous characters but significant opportunities for situation generation and interaction. Capitalizing upon recent research in the field, the system introduces a number of technical innovations both in terms of architecture (in the form of a dynamic regional prompt adapter) and in term of implementation (distillation of Small LLM). With an existing implementation, the paper includes elements of comparative evaluation,  both quantitative and qualitative.
weaknesses: From a fundamental perspective, there is a lack of awareness of some game design issues. The introduction is relatively naïve considering how these issues are addressed in game/play theory (Caillois, Huizinga). With the fine line between simulation and entertainment, and notwithstanding the reference to The Sims and Tamagotchi, contemporary audiences tend to have gameplay expectations that can only be met with sustained and meaningful (in the narrative sense) interactions. This feeds into the overall perspective of the evaluation methods which in the paper are primarily focused individual ‘event’ generation. While sustained UX evaluation may be at odds with the system’s current level of maturity, some of this could have been addressed through even slightly longer exchanges or chains of events construed as minimal narrative experience (which is claimed in the abstract but does not really materialize in the examples). The small examples given, including on Figure 1, do not convey a very strong sense of gameplay. 

There is no evidence that the number of user-simulator examples is at all sufficient for the intended purpose of multi-topic data collection. Nor is there any discussion of some hierarchical organization of topics that would come close to scenarios, game genres or elementary forms of plot backbones.

Despite the statement on replicability, the level of implementation details is unclear. Implementation details are rather cursory and uneven with some in-depth details but no systematic discussion, and minor duplications from other sections.

Evaluation has both positive (see above) and negative aspects.
Unless I am mistaken, Table I shows a couple of inconsistencies for results.
On Environment Consistency, how can 0.322 be the best score when it is in-between 0.381 and 0.257? How can 0.675 be the best score in-between 0.595 and 0.832?
It is difficult to find the Qualitative component of evaluation very convincing in the absence of a more systematic approach for generating test situations. From a similar perspective, the example Prompts do not contain advanced mechanisms for controlling response, or specific examples. One would thus wonder how LLM response can be kept consistent across runs, and what type of statistical sampling has been associated to LLM use?

Meta-review: The paper presents an interesting experiment in creating a generative game where the core "game engine" is based on LLMs and diffusion models. While obviously there is a long way to go, there are interesting things to learn from the paper. The "core technical" contribution of the paper is perhaps the regional IP-adapter used to ensure that placement of characters in images work, but the bigger contribution is the system as a whole. It would have been nice with a proper user study to understand how people play with the system, but... next paper?
The first version of this paper was seriously lacking in its related work section, essentially ignoring the most relevant research community, but this has been much improved in the updated version.

Decision: Accept (Poster)