Essays

Coding got easy. Do we still need to learn more languages?

·11 min read·한국어
ContentsWhat 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 tongueReferences

This 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. Under 'UE5 → UE6' are three boxes. The left box, 'Removing UE5 systems', lists Actors, Blueprints and C++ Gameplay Framework. The middle box, 'New UE6 systems', lists Entities & Components, Verse Programming, Verse Gameplay APIs and MCP + Python. The right box, 'Upgrade strategy', reads AI-assisted migration, with Early Access 2027 below.

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.

The same 'buy an item from a shop' feature side by side, in the case where the inventory is full and Add fails. On the left, C++ (UE5 gameplay) takes the gold first with P->Gold -= Price;, then simply ends at the return; under if (!P->Inv->Add(Item)). Those two lines are shaded teal and labelled '① gold goes first' and '② ends, no item', and the result below reads Gold 500 → 400, Item none, with a teal 'Half-changed state' tag. On the right, Verse (UE6) has set P.Gold -= Price and P.Inv.Add[Item] shaded orange together under Buy(P:player)<decides><transacts>:void =, and an arrow running back up from the Add line to the set line says 'on failure, rolls back', and a comment at the bottom reads 'on failure, all changes undone'. The result reads Gold 500 → 500, Item none, with a orange 'Rolled back whole' tag. Teal is state left changed halfway; orange is what the language undoes for you.

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.

A figure comparing 'polyglot' in 2015 and 2026, with two bars for each year on a cost and scarcity axis that has no scale. In 2015 (polyglot = someone who can write in many languages' syntax), the 'Writing (syntax)' bar is long and filled teal, reads 'learn each syntax, write it yourself' and is marked 'scarce'. 'Reading, judging (worldview)' is a shorter, empty orange outline. A dashed arrow labelled 'scarcity moved' runs down. In 2026 (polyglot = someone who reads and judges through many languages' worldviews), 'Writing (syntax)' has shrunk to a short, empty teal outline next to 'the agent writes it', while 'Reading, judging (worldview)' is long and filled orange, lists memory model · failure handling · state model · structure, and is marked 'scarce'.

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.

On the left, 'Stacking by inheritance' (Unreal · C++): four boxes, AActor, APawn, ACharacter and AMyCharacter, run down in a column, with is-a arrows rising from each box to the one above. Next to AActor are virtual BeginPlay() and virtual Tick(); next to AMyCharacter at the bottom, highlighted in orange, are override BeginPlay() and override Tick(). On the right, 'Attaching components' (UE6 · Verse Scene Graph): a single entity box holds transform_component, mesh_component and the orange health and heal components, and two child entities hang from it by lines. One carries mesh_component, the other a orange heal. Orange is code I write; grey outlines are what the engine provides.

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.

Translation key duplicatorInteractive
New key: the copy, carrying the original’s bitting and keywayWards: four inside the lock, from the face in: structure, state, failure, memoryThe bitting is copied 100% for every pair; the keyway is what differs. Zig→Rust differs only in the memory model, so the key passes three wards and goes deep (translation). C++→Rust also differs in failure handling (exceptions → Result) and stops after the second ward. C++→Verse differs on every axis, memory (manual → managed), failure (→ failure contexts), state (mutable → transactional) and structure (inheritance → entities and components), and is stopped at the first ward by the face (adaptation). No pair goes all the way in and turns.

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.

Three ways to failInteractive
HP needle: the target’s healthCarriage: one callPlayers[0] takes a token, Heal(10) raises HP from 90 to 100, then the IsAlive check fails: a dead player’s token pops a pin once it lands on the carriage, and the gauge foot at station 3 stops on that pin instead of seating. In Rust the failure is an Err value: the carriage drops into the tray at the end of a siding, wired to the caller, who has to take it. In Go the err is checked by hand and returned. In both, the heal already happened, so HP stays 100. In a Verse <transacts> function failure is control flow: the whole call fails and every change made inside it is undone, so the HP needle springs back to 90.

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.

The same logic, open the door when a player overlaps but only if they have the key, side by side in two languages. On the left, 'Blueprint · a language of wires' is a node graph. A thick grey wire runs from the white execution-pin triangle of a 'Player overlaps' node into a 'Has key?' branch node, and the branch's 'True' output runs on into an 'Open door' node. Nothing is connected to 'False'. A orange wire from the event node's 'Player' value pin passes through a 'Has key' node below and into the branch's 'Condition' pin. On the right, 'Verse · a language of text' writes the same logic in three lines: under OnOverlap(P:player):void =, the line if (P.HasKey[]): is highlighted in orange, with Door.Open() inside it. An equals sign sits between the two, and underneath it says 'Orange is the same key check · the branch you wire up becomes a single if line in text'.

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

GeekNews (Korean)

Bun · Jac

Polyglots · language and thought