The Terms That Moved

On September 22, 2023, the company announced substantial changes to its proposed Runtime Fee. According to Brendan Sinclair’s reporting for GamesIndustry.biz, games built on Unity Personal would be exempt. For Pro and Enterprise users, the revised arrangement would include a 2.5 percent revenue-share option and a promise to bill the lesser amount when compared with the engagement-based fee. The new fee would apply only to games using versions of Unity shipping in 2024 or later.

This was a retreat, not a wholesale cancellation of the Runtime Fee. That distinction matters. So does the boundary Unity now offered: developers could keep using their existing editor version under the terms applicable to it.

The number on the invoice was the most visible argument. Underneath it was a more consequential one: when a studio has spent years building on somebody else’s technology, what keeps that supplier from changing the bargain after the work is difficult to move?

The invoice arrives after the commitment

An engine is not a disposable accessory. It helps determine how a game’s code, assets, tools and production routines fit together. Changing engines is therefore not equivalent to shopping for a cheaper subscription. Depending on the project, it can mean rewriting systems, rebuilding workflows and checking that a game still behaves as intended.

The precise cost varies. There is no honest universal estimate for switching, and the available reporting does not establish one. But two developers’ accounts make the difference between an early choice and a late predicament unusually clear.

In Nicole Carpenter’s September 14 Polygon report, Blinkmoon chief technology officer Mike Wuetherick described a project that had recently moved from Unreal to Unity. He said the pricing announcement meant pausing work pending clarification. Because development had only just started, resetting would lose about a month’s work. His assessment was not that switching was free. It was that the team had encountered the risk early enough to consider absorbing it.

In the same report, Newfangled Games’ Henry Hoffman described a very different position. Paper Trail had been in development for four years. Licensing deals with subscription services were central to the studio’s financial model and had helped fund development. A large number of downloads would not necessarily bring a corresponding stream of new revenue.

These were developers describing their exposure to the original proposal, not evidence that either studio ultimately paid the feared charges. September 22’s revisions changed that proposal materially. Their accounts still explain why the initial announcement was so disruptive: a pricing decision can collide with financial commitments made long before it exists.

The calendar is part of the power relationship. Before choosing an engine, a studio can compare alternatives. Four years into a project, that same comparison comes with four years of reasons not to act on it.

An install is not a sale

Unity’s initial rationale, quoted by Polygon, connected the charge to distribution of its runtime: when a qualifying game was downloaded, the runtime was installed too. That describes a technical event. It does not establish that the event produces income sufficient to cover a new charge.

A purchased copy, a subscription download and a free distribution can all put software on a device while representing different financial arrangements. A fee attached to that common technical event reaches across those differences. Developers then have to establish which cases count, who pays and how exceptions will work.

Polygon documented the resulting uncertainty. Developers raised concerns about subscription services, demos, charity bundles, piracy and malicious installations. Unity issued clarifications, including that trials and demos would not incur charges, and said fraudulent installs would not be billed. Those concerns should not be retold as proof that every feared charge was definitely going to happen. The reporting shows a policy whose practical boundaries developers were still trying to establish.

The measurement question was not a decorative detail. Polygon quoted a Unity representative describing a proprietary model for estimating installs, while developers questioned how precise the counts could be. If the supplier determines both the billing rule and the measure used to apply it, the customer needs some usable way to inspect and challenge the result.

Otherwise, a studio is being asked to budget around a number it cannot reproduce. “Contact our team if something looks wrong” may be a necessary support route. It is not the same thing as a bill whose basis is independently understandable.

September 22’s movement toward self-reported figures and a revenue-share comparison addressed important parts of this problem. Revenue and engagement are not interchangeable, but offering the lower charge creates a different risk profile from an unbounded argument over installations.

That is a meaningful improvement. Calling every revision cosmetic would be as lazy as calling the original controversy a communications problem.

The useful part of the apology

Unity Create president Marc Whitten acknowledged that the company should have consulted more developers and incorporated more feedback before announcing the policy, GamesIndustry.biz reported. His stated goal was to sustain investment in the engine.

That is a legitimate goal. An engine requires maintenance, platform support and continuing engineering. Developers benefit when the tool they depend on remains viable. An argument that Unity must never change its prices would dodge the actual question almost as efficiently as Unity’s original rollout did.

The issue is how changes meet existing commitments.

A prospective offer lets a developer evaluate the price before accepting the dependency. Applying new economic conditions to work already built under a different understanding is another proposition. Even where the legal position is disputed, the planning problem is immediate: a studio must decide what it can promise its own partners while somebody upstream is revising the assumptions.

The strongest element in the September 22 announcement was therefore not the apology. It was the version boundary. Whitten said developers could remain on the terms applicable to the editor version they kept using. GamesIndustry.biz reported that previously released titles and games shipping with existing versions would be exempt from the new fee.

That gives a team something more concrete than reassurance. It creates a distinction between maintaining an existing commitment and accepting a new one.

It does not make all future decisions painless. Staying on an old version can eventually involve trade-offs around features, compatibility or support. Those are general software-maintenance considerations, not findings that Unity had imposed a particular new penalty. The point is that a right to remain matters most when remaining is technically practical, not merely permitted in a paragraph.

Trust needs a recoverable record

The dispute also exposed why access to old terms matters.

In a September 14 report, Game World Observer’s Evgeny Obedkov described developers discovering that Unity’s GitHub repository for tracking license changes was no longer available. The report also described the removal of a clause that had allowed developers, in specified circumstances, to continue using particular versions under earlier terms.

That reporting does not settle whether Unity could legally enforce every proposed change. Nor does it establish that the repository’s removal was undertaken to prepare the Runtime Fee. Obedkov explicitly noted that the changes might not be directly related. A suggestive sequence is not a finding of intent.

But the practical need survives that uncertainty. When a supplier promises that a particular version carries particular terms, developers need a durable record connecting the two. Otherwise, the apparent protection depends on reconstructing what a page said, when it said it and which version it covered.

For a software company, this ought to be an embarrassingly familiar problem. Versions need histories. Changes need readable differences. Important dependencies need records that do not disappear when the latest release replaces the old landing page.

A published promise is the beginning of that arrangement, not its entire implementation. Studios should be able to retain the applicable terms, identify subsequent changes and establish which conditions govern their project. Clear records help suppliers too: disputes become questions about an identifiable agreement rather than competing recollections of a launch announcement.

Trust is often marketed as warmth between a company and its community. Here it needs to look more like a well-kept changelog.

Protest worked; that is not a governance model

The September 22 changes show that developer opposition could affect the policy. Whitten’s acknowledgment of missed feedback makes it unreasonable to describe the response as irrelevant noise.

Game World Observer reported that Mega Crit, the studio behind Slay the Spire, had announced plans to move its new game to another engine. Polygon’s interviews supplied less theatrical but equally important evidence: paused work, uncertain budgets and concern about whether existing business models remained viable.

These are different forms of resistance. Public criticism challenges a decision’s legitimacy. A credible plan to leave threatens future business. A small studio explaining its financing reveals consequences the pricing model may have flattened away.

None is a substitute for an ordinary, reliable process through which affected developers can shape consequential changes before they are announced.

A platform can listen after a crisis and still leave its users dependent on generating the next crisis. That is a costly feedback mechanism. It asks developers to divert time from making games into making a supplier’s mistake impossible to ignore.

It also raises a representation problem. The ability to attract attention is not distributed according to exposure to harm. A small team with no recognizable title may face serious risk without being able to turn a public statement into industry news. A legitimate process should not require every affected studio to become a successful pressure campaign.

The coherent arrangement is not one in which everybody quietly accepts the same rule. It is one in which the people carrying a rule’s consequences can help test it, challenge its application and preserve meaningful choices. Order achieved by ignoring those people is merely an orderly transfer of risk.

Who gets to hold the bargain still?

The practical standard is more demanding than “Unity listened,” but less mystical than asking a corporation to become benevolent.

Keep terms attached to identifiable versions. Explain charges in units customers can understand and verify. Consult across different business models before treating one technical event as a universal measure of commercial success. Preserve a workable route for maintaining existing projects without automatically accepting a new bargain.

For developers, evaluating an engine should include evaluating those protections. Performance, tooling and platform support remain essential. So does asking what happens when the supplier’s preferred business model stops matching yours.

None of this requires pretending that dependence can be abolished. Useful tools create relationships, and relationships create obligations. Unity contributes engineering; developers contribute money, labor, games and an ecosystem that makes the engine worth adopting. A sustainable exchange must account for both sides rather than treating accumulated developer investment as an opportunity to tighten the terms.

September 22’s revision moved toward that standard. It reduced exposure and drew an important line around existing versions. It did not prove that trust had been restored, that every studio’s concern was resolved or that future disputes would have a fair route through them.

The fee can be revised in an announcement. The years built on the engine cannot.

That is why the next essential feature is not another apology. It is a bargain developers do not have to mobilize an industry to keep.