Jay Little
Unity Killed Modern Proprietary Gaming For Me

09/15/2023 19:39:55

As some of you undoubtedly have heard Unity, the company behind one of the most prolific game engines of our time called Unity Engine, recently announced some changes to their pricing. On the surface this may sound like quite a big nothing burger if you aren't familiar with the process of how software is made, let me assure you: This announcement is rocking the entire gaming world.

Note: This post is a follow-up to my 2019 post "My Modern Gaming Escape Plan". If you haven't read it or have gasp had the audacity to forget it over the last four years, I strongly advise you to read it (again) first.

So what's the big deal? Well let's just quote the most important part of Unity's blog post (linked above) for the particulars:

We are introducing a Unity Runtime Fee that is based upon each time a qualifying game is downloaded by an end user. We chose this because each time a game is downloaded, the Unity Runtime is also installed. Also we believe that an initial install-based fee allows creators to keep the ongoing financial gains from player engagement, unlike a revenue share.


Games qualify for the Unity Runtime Fee after two criteria have been met: 1) the game has passed a minimum revenue threshold in the last 12 months, and 2) the game has passed a minimum lifetime install count. We set high revenue and game install thresholds to avoid impacting those who have yet to find scale, meaning they don’t need to pay the fee until they have reached significant success.

Unity is transitioning from just charging devs for the right to use their engine via a subscription model to now also charging devs each time any of their products which use the Unity Engine / Runtime are installed by an end user.

This is utterly mind blowing. This is not how things are done in software. While the fees will only be assessed on installs starting from January 1st, 2024 and onwards the lifetime installation tallies that you have to reach in order to be charged are from the entire lifetime of the product. This means that every time an end user installs the game on a new piece of hardware, Unity plans on charging the dev at least $0.20 for that. Despite the fact that the dev's revenue stream is not in any way directly tied to this activity. Online game storefronts generally don't restrict the number of installs or number of devices a game you have purchased can be installed on (though some nasty games implement other middleware that allows for these kinds of restrictions).

How does Unity manage to tally this? Are the game distribution platforms like Epic, Steam, Xbox and Playstation sharing this information with them? Certainly not. That means that the actual Unity Engine code must be providing this information to Unity (a fact they refuse to admit to even though it clearly must be true). Since they are using lifetime installation tallies, this heavily implies that the spyware required to accomplish this has been present and active in the Unity Engine for quite awhile.

How big a deal is this for gamers who value their privacy like myself? As of right now, there is no definitive or simple way of absolutely determining what engine, in addition to any other middleware, a particular game uses. Unity is quite popular with indie devs however and through a variety of sources including SteamDB along with locally scanning file names in my game installs, I have determined that at least 20% (262) of my Steam Library (1260) is compromised of products that use this software. Sad to say, while SteamDB was helpful it's not 100% accurate here as games like Slay the Spire, which I know for a fact make use of Unity Engine are not listed as such in their database.

In any event, as I talked about back in 2019, I knew that my time in modern gaming was coming to an end. While I have played a few modern games since then, I have rarely paid full price for any of them. In the few circumstances in which I did (e.g. Baldur's Gate 3), I just didn't have the motivation to progress past the first few hours regardless of how good the game itself may have actually been. My relationship with gaming has become much less formal and consistent over the last few years.

This Unity situation puts me in a very awkward position. The reason for this is simple: Despite me attempting to replace proprietary software with Free and Open Source Software (FOSS) in most areas of my life, gaming has largely remained exempt from this initiative. What's happening now with Unity (aka trash software company pulling the rug out from under end users and devs alike all in the name of stank ass greed) is the exact kind of behavior that inspired me to start transitioning to non-gaming FOSS software years ago.

I came up as a software developer in an era (late 90s, early 00s) when Microsoft ruled the roost and they wielded their power in some of the most egregious ways imaginable. They were constantly changing the rules and screwing over their end users but due to vendor lock-in, a lot of people just decided to grin and bear it. I did not. This is why I'm a hardcore Penguin (aka Linux user) nowadays. This is also a large part of the reason why I am opposed to the tech industry's nearly universal embrace of a handful of cloud providers.

The harsh reality of FOSS gaming is this: It ain't going to cut it. While FOSS gaming is a thing, it's still essentially in its infancy. Thankfully there is a wonderful FOSS game engine that can compete with Unity in a lot of respects called Godot so all hope is not lost.

But this begs the question: Even if all of those indie game devs move to Godot, does this really solve the core problem? No it really doesn't. For those of you not seeing where this is going, let me spell it out for you:

Usage of proprietary software requires one to compromise on their own freedom. In certain situations this may be acceptable. However as software becomes more complicated and more developers rely upon middleware providers to fill in the gaps, end users now need to contend with a new reality in which not only do they need to trust the developer they're buying the software from, but they also by default must extend that trust to the developers of the middleware used to build it. This is in spite of the fact that generally do not any way of being even remotely aware of what that middleware is.

I just can't do that anymore. Unity Engine games have clearly been spying on end users for years. Goodness only knows what other information they are harvesting and how long they have been harvesting it. So as of this moment, I have uninstalled all known Unity Engine games and refuse to purchase anymore Unity engine games.

However, that's not enough... the reality is that I have no good way of identifying with one hundred percent certainty which games use Unity and which games don't. Certainly not before purchase and only most of the time post purchase (via scanning file names within the install directory). So this leaves me in a position where if I am committed to not rewarding Unity's behavior, I now must walk away from Indie gaming altogether.

Lemme tell you, this fucking sucks. FOSS gaming ain't there yet (unless I want to play DCSS for the rest of my days, which despite its awesomeness, I don't as variety is the spice of life). So that leaves one true friend, good ole Retro gaming.

Yes Retro Games are generally proprietary. But here is the thing. Pretty much all of my retro library is associated with systems that weren't always online and even in the case that the more modern retro systems are, the games are run via emulators where I can leverage a large degree of control over whether or not I wish to allow for that to happen via configuration of said emulator.

My DOS games aren't going to violate my freedom to privacy. Neither are my NES, Gameboy, SNES, Genesis, Apple II and Commodore 64 games. Because of the technological limitations at the time and the hoops I have to jump through to run these games, their power over me as an end user is inherently limited.

Please note: This doesn't make them equivalent to FOSS games, it just makes them substantially less dangerous than modern games.

That means the time has come for me to actually retreat from modern gaming. As a lifelong gamer (almost 40 years now) this is a sad day. Indie games were really the only thing keeping my status up as an official active member of the gaming community and those are now soured for me. Yes I know a lot of Indie games don't use Unity. But who knows what other craptacular middleware they are using. These are proprietary software products and ultimately because of that the degree of transparency afforded to the end user is limited.

Does this mean I'm going to delete my Steam account or my Playstation network account? No. But it does mean that as of right now, I'm looking to limit my use of both of those services in every way possible. In time, assuming I don't reverse my position, my end goal is stop using them altogether.

Let me close by saying "Fuck you Unity". I realize that if you asshats hadn't pulled this, eventually some other enshittified middleware provider would've done it, but damn. Dealing with this drama and writing this blog post was not how I predicted my week was going to go.

So thanks for that.

[Top] [Rss] [Email]