AI Engineer World's Fair 2026
The Next Game Engine Won't Have a Manual
Loading slides…
Read the talk
The Next Game Engine Won’t Have a Manual
Nereu turns requests for robots, rain, and camera movement into reusable engine behavior, with an asset tag system and scene context tailored to the user’s editing focus.
From a talk by Arturo Nunez
Start with a robot
Ask for a robot, choose one, and press play. Nothing happens yet. The asset is in the scene, but being a robot does not tell the engine how it should behave. In Arturo Nunez’s recorded demonstration of Nereu, its assistant, Bibi, first finds robot assets through their tags or descriptions. Arturo selects one to become the character the player will control.
The next instruction supplies the missing behavior: “Make this robot move with WASD and animate it”. Bibi applies the request, and the character moves. The user describes an interaction familiar from playing games without first learning how to import a model or write its movement code.
The scene grows through the same conversational process:
- Add buildings. The asset library offers futuristic buildings, a warehouse or store, and a castle. Choosing among them feels more like assembling toys or Lego than committing to a finished game design.
- Add rain. The request creates a particle system configured to look like rain.
- Follow the character. Without a following camera, the robot can leave the view. Bibi adds and configures a camera targeting the main character, keeping it visible as it moves.
Each request maps a recognizable game idea onto concrete engine machinery. The user still decides what belongs in the scene and what it should do.
Arturo estimates that this recorded scene-building sequence could be completed in a couple of minutes, with the assets already supplied and without learning to code or import them. That is the promise behind a game engine without a manual: reach a playable interaction using the vocabulary of the game itself.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Making games should be fun, too
Arturo’s motivation comes from repeatedly watching developers encounter the same obstacles. He describes almost a decade at Unity, where challenges that initially seemed interesting became frustrating through repetition. He subsequently worked at MongoDB, explored AI and data management, and helped a startup with version control for game assets. The recurring question was why creators should spend so much energy solving familiar infrastructure problems again.
A commercial release is not everyone’s desired destination. A creator can spend years making a game and then discover how difficult it is to sell in a crowded market. For someone treating game development as a creative outlet, the process itself needs to be rewarding.
That process demands an unusually broad set of skills: programming, 3D modeling, rendering, music, animation, and real-time camera composition. Large teams can distribute those responsibilities; small teams require people to wear several hats. Even a technically successful implementation leaves the hardest design requirement unresolved: the game has to be fun. Arturo wants that enjoyment to extend to the developer, instead of letting production and sales pressure displace the craft. Making games should not require becoming a professional game developer first.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Describe game intent instead of engine setup
Powerful engines and powerful language models do not automatically make game creation accessible. Connecting an agent to Unity or Unreal can still require the user to know the engine’s vocabulary and ask for the right code. Arturo’s example is a following camera: he has seen LLM demonstrations generate essentially equivalent camera logic repeatedly. The request is about game design, but the assistant’s working context pulls it toward implementing engine details.
A conventional controllable character illustrates the accumulated setup. Import a mesh, give it a renderer and animator, add a rigid body and collider for physics, attach an audio source, and then supply movement logic and game rules. Much of this is recurring work, yet the creator must still understand component descriptions and the many settings exposed by the editor.
The proposed abstraction is an asset with intent tags. Rendering and, where appropriate, physics remain underneath. Above them, tags describe what the asset means in the game: a character, animated, able to double jump. The vocabulary resembles a player tutorial—press A to jump, then press A again in the air to double jump. Event rules use the same level of description: collecting a coin increases the score.
| Concern | Engine-facing description | Game-facing description |
|---|---|---|
| Appearance | Mesh, renderer, animator | Animated character |
| Movement | Physics components and movement logic | Character that can double jump |
| Rules | Game-rule implementation | Collect a coin to increase the score |
The intent layer does not eliminate rendering or physics. It makes those systems available without requiring every creator to configure their underlying parts.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
How the asset tag system selects behavior
Nereu calls this mechanism the asset tag system, or ATS. It draws on entity component systems and data-oriented design: describe objects through data, then let systems query that data to decide which objects they should process. Instead of generating a separate movement implementation for every asset, a shared system finds assets carrying the relevant combination of tags.
The diagram shows a car tagged vehicle, player, and driveable, alongside a building with no tags. Its UpdateVehicleMovement system acts on the matching car; the building remains still. A minimal JavaScript expression of that selection rule looks like this, using the slide’s driveable spelling:
javascript
const assets = [
{
id: "car",
tags: new Set(["vehicle", "player", "driveable"]),
},
{
id: "building",
tags: new Set(),
},
];
const requiredTags = ["vehicle", "player", "driveable"];
function selectMovementTargets(world) {
return world.filter((asset) =>
requiredTags.every((tag) => asset.tags.has(tag))
);
}
const movementTargets = selectMovementTargets(assets);
// The car matches; the untagged building does not.
The reusable part is the query and the system behind it. An asset’s visual appearance does not determine whether it qualifies for a behavior.
That separation permits a deliberately playful example: give a building vehicle and drivable tags, and it can become a participant in a Mario Kart-style game. A building need not be scenery just because its model looks like architecture. For the particular player-controlled query above, it would also need the player tag.
Bibi helps users discover and apply these capabilities. If someone does not know how to make a car move, the assistant knows the available tools and tags and can apply the appropriate ones to the referenced asset. The engine already owns the behavior; the assistant connects the user’s request to it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From a request to a scene update
The assistant’s update loop combines familiar agent mechanics with a constrained engine interface:
- Receive the request. The user describes what they want to change.
- Assemble context. Nereu includes scene information, asset themes such as robots or medieval objects, and the user’s description of the intended game.
- Call tools. The agent makes calls that add or remove tags.
- Apply the built-in behavior. The engine’s existing systems interpret those tags.
This gives the model a vocabulary of supported operations rather than requiring it to invent the implementation for each request.
Nereu intentionally has no user scripting system in the version described. The engine itself is JavaScript running in the browser, so developers willing to extend it can do so, but ordinary users are not expected to write scripts. The interaction ends with updates to the scene.
The difficult design work is deciding which tags and systems can express games across genres and across different descriptions of the same intention. A request for a scary platformer includes both mechanics and mood. Making it feel scary can require changes to lighting and post-processing, not just movement rules. Supporting that request means decomposing its meaning into engine capabilities that can work together.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Building the engine and teaching its assistant
Arturo describes building at an unfamiliar scale and speed through daily work with AI. He discusses ideas with Claude, then brings in domain expertise. For a lighting feature, for example, he asks an industry friend who specializes in lighting and uses that knowledge to shape the tools. Simplification is part of the work: settings and features he rarely sees people use are candidates for removal.
As tools are built, their definitions are supplied to Bibi, keeping the assistant informed about the engine’s growing capabilities. The development loop therefore connects two uses of AI: helping Arturo build Nereu, and helping Nereu’s users build games. At the time of the talk, he tentatively describes the product as a closed alpha, with a small group using it and providing feedback that starts the next iteration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Describe the library, then focus the scene context
The assistant needs useful descriptions of assets before it can find them. Arturo reports a library of approximately 6,000–7,000 assets. Initially, he had their names and 3D files, which was not enough to make manual descriptions practical. He took screenshots and passed them through a vision model to describe and tag objects such as astronauts, knights, and castles. Vision supports asset preparation; the interactive assistant primarily uses an LLM.
Once assets are assembled into a scene, sending all their state to the model creates another problem. Arturo estimates roughly 100 assets in the example scene, many of them grass that could be ignored. Including every object at full detail would enlarge the context without necessarily helping the assistant understand the current edit.
Nereu borrows an analogy from rendering: level of detail. An object close to the camera may use a higher-quality texture, material, and model. A sufficiently distant object can use a much simpler representation—even a cube in Arturo’s example—because the viewer cannot distinguish the missing detail. The same principle can guide how much information an assistant receives about each object.
When the user selects a knight, the editing focus helps establish which surrounding objects deserve more detail. High-priority objects can be represented with their tags and the values of settings on those tags. Other nearby objects can receive a shorter description, such as identifying an object as a player and giving its position, without including its entire state.
| Context priority | Information supplied |
|---|---|
| Higher relevance to the edit | Tags and tag-setting values |
| Lower-detail nearby context | Brief identity and position |
As the user moves around and modifies the scene, Nereu updates the context supplied to the assistant. The useful transfer from rendering is selective fidelity: retain enough detail for the current task, and change that allocation as the focus changes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep the creator involved
Bibi’s purpose is to get people unstuck while they make a game. Arturo does not want this product to generate complete games in one shot that nobody subsequently plays, even though he acknowledges demand for one-shot generation elsewhere. He wants people to enjoy creating something and share it with friends and family.
Learning the language of game design is part of that goal. Learning programming is not a prerequisite or the intended curriculum, although some users have told Arturo that using the tool helped them understand programming concepts that had previously been unclear. The creative activity remains the center of the experience.
World models offer a different direction: generating interactive worlds on the fly. Arturo expects that direction to become a distinct medium, even if people continue to call its results video games. He argues that real-time world-model generation at 4K and 60 frames per second remains far away. This is his forecast about a demanding target; he identifies physics simulation as an additional challenge while remaining enthusiastic about the work.
At the close, Arturo offers to add interested people to the waitlist, including those who want to share the tool with children or friends. His own testing captures the experience he wants to enable: bring in an astronaut, add a dinosaur, and make them walk around. It recalls the enjoyment that brought him into game development roughly two decades earlier, before that work began to feel disappointing. Building and playing with Nereu has made it fun again, and he wants more people to experience that pleasure.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Further reading
Arturo's introduction to Unity's Entity Component System, with project files and further reading on data-oriented design.
Unity's versioned manual explains how simpler meshes and billboards reduce rendering work for distant objects.
DeepMind's announcement describes interactive generated worlds at 720p and 24 frames per second, along with consistency and interaction limits.
Full transcript
Loading transcript…