Contents
What Epic wants to change is more than syntaxSimilar languages can be translated; different ones have to be rewrittenIt takes both languages to spot translationeseLearn languages that think differentlyLosing a mother tongueReferencesThis week what Tim Sweeney announced at Unreal Fest Tokyo must have come as quite a shock to a lot of game developers. He said Unreal Engine 6 will do away with Blueprint, Actors and the C++ gameplay framework. Gameplay logic moves to Verse, the language already used in the Fortnite editor (UEFN), and to Scene Graph, which is built on entities and components. C++ stays only in the lower layers of the engine, such as rendering and physics.

A slide from Unreal Fest Tokyo 2026. From left: what UE6 removes, what it adds, and how projects move over.
Epic also said it would prepare an AI conversion tool to move existing projects over to Verse. Sweeney admitted the change is painful and apologised to developers who love Blueprint.
So one of the most widely used game engines in the world is going to set aside C++, the industry standard, for a language it made itself. Why would it do that?
What Epic wants to change is more than syntax
Epic named three reasons itself.
The first is productivity. Epic said that using AI tools in-house had raised its productivity in programming, debugging and level design by 1.5 to 4 times.
The second is portability. If gameplay sits on the same language and the same Scene Graph, content made for one game becomes easier to move to another game or into Fortnite.
The third is 'compatibility with AI-assisted development'. In other words, the language was chosen with the agents that write code on top of the engine in mind, as well as the people who use it.
All three make sense, but on their own they don't explain enough. If productivity and portability were all Epic wanted, it could have picked a language that is already widely used, like C# or Python. Instead, Epic brought in the people who made Haskell and built a new language from the functional logic family, which has hardly ever been used in the games industry.
As I see it, the real reason lies in the way Verse looks at the world. Verse treats failure as control flow rather than as an exception, and it wraps state changes in transactions that are rolled back entirely when something fails. In an online game where tens or hundreds of people change state in one world at the same time, 'state that changed only halfway' is the hardest kind of bug to deal with. If the language never leaves state like that behind in the first place, the scale the engine can handle changes. Scene Graph, which attaches components to entities instead of using inheritance, points the same way. Assembling independent parts is easier to split up, move and verify than a deep inheritance chain.
So what Epic wants to change is how people think about gameplay code, and syntax is the smaller part of that. At this point an old phrase came to mind: the polyglot programmer.
The polyglot programmer of the AI era is not someone who writes code in many languages. It is someone who reads code from the viewpoints of many languages, spots translationese, decides which worldview fits the problem, and takes responsibility for that decision.
Similar languages can be translated; different ones have to be rewritten
A polyglot programmer usually means a developer who is fluent in several programming languages and picks the tool that suits the problem. Articles on the subject tend to give the same reasons: knowing several languages broadens your view, lets you choose the right tool for the situation, and keeps your career steady even if your main language fades. Over the past ten years this advice has barely changed.
This year, though, the premise behind it was badly shaken. The Bun team ran dozens of Claude agents in parallel and moved more than 500,000 lines of Zig code to Rust in less than two weeks. The result passed 99.8% of the existing test suite. That is work someone who knew both languages deeply would have had to spend years on.
The ability to carry code from one language to another can now be bought. A developer who has only ever written Kotlin can build a CLI tool in Rust with an agent in an afternoon. Judged only by the ability to 'write' code in several languages, everyone is a polyglot now.
The Bun move and the Unreal move look alike from the outside, but they are quite different in nature.
Zig and Rust are both imperative systems programming languages. Both handle memory directly, build programs out of structs and functions, and have similar execution models. What the program does did not change. It was a matter of carrying the same meaning into a different syntax, translation in the literal sense. So a figure like 99.8% was possible.
The road from C++ to Verse is different. Unreal's C++ gameplay code lives in an object-oriented, imperative world: it inherits from a class called Actor, overrides virtual functions and changes state as it ticks every frame. Verse is a functional logic language, and as we saw earlier, it handles inheritance, failure and state change in entirely different ways.
This goes further than retelling the same story in another language. The story's setting and its whole grammar change. It is less a translation than an adaptation, the way a novel is reworked for the screen.
I built this difference as a machine: a key duplicator. The teeth are the code's logic, and the machine always copies them 100%. The trouble is the four grooves that run along the side of the key, the keyway. Those grooves are the language's worldview: memory model, failure handling, state model and structure. A line-by-line copy inherits the original's grooves exactly as they are. Put a key cut that way into the target language's lock and it stops at the first ward its grooves don't match. Switch between language pairs and see how far the key goes in.
Code translation as a key-duplicating machine: a stylus traces the original key (the source language) while a wheel cuts the same depths into a blank, so the bitting (syntax and logic) is always copied 100%. Four grooves along the blade, the keyway, are the worldview: memory model, failure handling, state model and structure. The copy carries the original’s keyway into the target language’s lock and stops at the first ward that doesn’t fit. Zig→Rust differs only in memory, so three of four wards match and the key goes deep (translation); C++→Rust differs in memory and failure handling, two match; C++→Verse differs on all four axes and is stopped at the face (adaptation). No pair turns the lock.
From Zig to Rust only the memory model differs, so the key goes in deep. From C++ to Rust failure handling differs as well, and it stops halfway. From C++ to Verse all four grooves differ, and it is stuck at the entrance. In all three cases the teeth were cut exactly the same. And in none of them does the key turn the lock. With the original's grooves left in place, the target language's door won't open. That is the state of the translationese code I am coming to next.
It takes both languages to spot translationese
Korean has a word, beonyeoktu, for translationese: writing that still carries the shape of the language it was translated from. Take '~에 의해 이루어졌다', literally 'was accomplished by ~', or '~를 가지고 있다', 'is holding ~'. The first borrows the English passive with its 'by', which natural Korean mostly avoids. The second borrows English 'have', where Korean would simply say that something exists or describe it directly. Neither is grammatically wrong, but the moment you read them you can tell they were carried over from English, because the structure of the original is still sitting there in the translation. To spot translationese you need to know both languages. Someone who knows only Korean feels that something is off without being able to say why, and someone who knows only English never notices anything odd in the first place.
Code has translationese too. Take the logic that heals the first player if that player is alive. Written in Unreal C++, it looks roughly like this. The example is simplified for explanation.
void AMyGameMode::HealFirst()
{
if (Players.Num() == 0) return;
AMyCharacter* Target = Players[0];
if (!IsValid(Target) || !Target->IsAlive()) return;
Target->Heal(10);
}Carry it into Verse line by line, and you get this.
HealFirst(Players:[]player):void =
if (Players.Length = 0):
return
if (Target := Players[0]):
if (Target.IsAlive[]):
Target.Heal(10)It compiles and it works. Anyone who knows Verse, though, will spot the awkward parts at once. In Verse, indexing an array with Players[0] is a failable expression to begin with. If the array is empty, it fails and that branch doesn't run. So the first if, which checks the length beforehand, isn't needed. It is a defensive C++ habit left behind like a fossil. Written the Verse way, it looks like this.
HealFirst(Players:[]player)<decides><transacts>:void =
Target := Players[0]
Target.IsAlive[]
Target.Heal(10)<decides> marks the function as one that can fail, and if any expression in its body fails, the whole function fails. <transacts> marks that when it fails, any state it has changed up to that point is rolled back. In Verse, failure isn't an error. It is an ordinary branch that says 'not this way'.
The AI conversion tool will carry C++ over to Verse. It will get the tests to pass, too. Whether the result is Verse written as Verse or C++ wearing Verse syntax is a separate judgement, though, and only someone who knows both languages can make it.
There is an irony in this, though. Compared with C++, very little Verse code is public. Today's language models handle languages with plenty of training data well, and languages like Verse comparatively poorly. A language chosen for its AI compatibility is the one AI is most likely to write with translationese. For a while yet, polishing the conversion tool's output into proper Verse will be left to people.
Learn languages that think differently
There is no need to memorise syntax. The agent knows it for you. What you do need is to take in each language's worldview through practice. For that, learning one language each from different ways of thinking pays off far more than learning several similar ones.
Write the HealFirst we carried into Verse earlier in Rust and Go, and yet another philosophy shows.
fn heal_first(players: &mut [Player]) -> Result<(), HealError> {
let target = players.first_mut().ok_or(HealError::Empty)?;
if !target.is_alive() {
return Err(HealError::Dead);
}
target.heal(10);
Ok(())
}func HealFirst(players []*Player) error {
if len(players) == 0 {
return ErrEmpty
}
t := players[0]
if !t.IsAlive() {
return ErrDead
}
t.Heal(10)
return nil
}Rust turns failure into a type, so the caller can't ignore it. Go keeps failure as a plain value and has you check it every time, somewhere easy to see. Verse makes failure the control flow itself.
The difference shows most when something fails after state has already changed. Say the heal happens first and the check in the next step fails. In the machine below, a carriage on a rail passes three stations in turn. At the first it takes out the target, at the second it raises the health gauge by 10, and at the third it runs a check that can fail. Choose a language with the handle, set the check to fail and run it.
A rail bench that runs the same game logic in three languages: the carriage takes the first token from a magazine (Players[0]), a press raises the HP dial from 90 to 100 (Heal(10)), then the last check (IsAlive) fails (a pin on the dead token stops the gauge foot short). In Rust a diverter gate drops and the carriage goes down a siding to a tray wired to the caller; in Go an err flag pops up and the carriage returns along the main line; in both, HP stays at 100. In Verse the carriage runs back to the start and the HP needle springs back to 90 (rollback). When the check passes, all three end at the end stop with HP 100.
In Rust and Go the failure reaches the caller, but the health that went up stays up. If you want to undo it, you have to write that code yourself. In Verse the carriage returns to where it started, and the gauge needle goes back to its original value too. A failed call leaves no trace on the world. The three versions do the same job, yet their attitudes to failure could hardly be further apart.
Alan Perlis wrote: A language that doesn't affect the way you think about programming, is not worth knowing. Someone who has spent years in a language that treats failure as a type thinks about failure first. Someone who works in a language that treats it as a transaction thinks first about whether a change can be undone.
How we learn has to change as well. Research from Anthropic found that participants who learned by asking the AI about concepts and reasons understood more than those who only had it generate code. Asking an agent to write code in a new language won't teach you that language. With the code it wrote in front of you, you have to keep asking why it was done this way here and how this is usually written in this language.
There is also a test you can apply to yourself. If you can find the parts of an agent's code that are 'not like this language', you can say you know the language. If you can't, so far you only know how to write in it.
Losing a mother tongue
Let me go back to Sweeney's apology. The Unreal ecosystem has plenty of designers and artists who have made games by wiring Blueprint nodes together, and plenty of programmers who have worked with the C++ gameplay framework for more than ten years. For them this change is a lot more than swapping one tool for another. They have to put down a mother tongue they have used for years and learn to think again in an unfamiliar language. And it happens to a whole community at once. So calling it painful doesn't sound like an exaggeration.
AI has made the number of languages we can write in practically unlimited. It has not widened the world we can think in. Widening that world still starts with a person stepping into an unfamiliar language and trying to think the way it does.
What Unreal wanted to change by choosing Verse over C++ was also how people think about gameplay code, and syntax was the smaller part of that. We can hand syntax over to the agent, but the worldview has to stay with us.
References
Unreal Engine 6 · Verse
- GameFromScratch — The Future of Unreal Engine 6
- Inven Global — Epic Games will remove Blueprints and Actors from Unreal Engine 6
- Algosyntax — UE6 Removes Blueprints and Actors: What Epic Announced
- Epic Games — Verse Language Reference
- Augustsson et al. — The Verse Calculus: A Core Calculus for Deterministic Functional Logic Programming (ICFP 2023)
GeekNews (Korean)
- Critical thinking when agents do the work (Korean, 4 Nov 2026)
- AI is forcing us to pay down 40 years of technical debt (Korean, 4 Nov 2026)
- Practical principles for developing with agents (Korean, 3 Nov 2026)
- How to learn machine learning in 2026 (Korean, 3 Nov 2026)
- In 2026, 'how to use AI' is worth nothing (Korean, 27 Oct 2026)
- If AI writes the code, why use Python? (Korean, 12 May 2026)
Bun · Jac
- The Register — Bun posts Rust porting guide
- Microsoft — A 10x Faster TypeScript
- Anthropic — How AI assistance impacts the formation of coding skills
- The Register — Michigan prof creates Python-like Jac language for AI agents
Polyglots · language and thought
- What is a Polyglot Programmer and Why You Should Become One (Medium)
- Alan J. Perlis, Epigrams on Programming, ACM SIGPLAN Notices, 1982
- Kenneth E. Iverson, Notation as a Tool of Thought, 1979 ACM Turing Award Lecture
- Umberto Eco, Mouse or Rat? Translation as Negotiation (original Dire quasi la stessa cosa, 2003)
- Ludwig Wittgenstein, Tractatus Logico-Philosophicus 5.6