Game Maker, Security, and Freedom

So Game Maker just got bought by a gambling company, and as the ancients have foretold, the gnarled old Lars has duly appeared from his hermitage with semi-inflammatory opinions on the subject:

As you can see from the replies this led to a lively discussion with a few folks. (It's cool, we're all still friends!)

So this gives me an angle slightly different from the usual pundit-driven speculation about the exact future of Whatever-Company-Was-Just-In-The-News. I want to take this broader.

Let's talk about Security and Freedom.

So when I started singing the praises of Open Source on twitter I ran face-first into a predictable argument. A lot of the commentary (including my own) took this general format:

Alice: X is great because it solves [my] problems!

Bob: Nuh-uh! X is bad because it doesn't solve [my] problems!

Alice: You're stupid!

Bob: No, you're stupid!

And so on.

Basically, I was making an argument valuing freedom over security, and others replied with the opposite values, which isn't so much an argument as two sides yelling past one another.

So some background.

Long-time readers will know I used to use Flash, and having been burned, moved to OpenFL, a fully open-source re-implementation of the Flash API using the Haxe programming language, that has none of Flash's limitations -- you can output your games to native hardware-accelerated C++ builds (for desktop or mobile), as well as HTML5 and it even has legacy cross-compilation to output Flash SWF files if you want. I often describe it as a "2D Unity" (it can technically do 3D as well by exposing an OpenGL context but it's nowhere near as fancy as Unity).

I've since joined the OpenFL team and we're currently working on extending OpenFL's C++ export functionality to support game console targets, but that's not done quite yet.

But before my transformation into Captain OpenSourcePants, I used to be that guy who always popped up in every "Flash sucks because reasons" article vociferously defending it. Yeah, Flash was proprietary. Yeah, it was slow. Yeah, it had security issues. But it just worked, and it worked everywhere (this was before Mobile took off). It worked on windows, it worked on mac, it even worked on linux! And it was so easy to distribute! You just put it up on a website and sent people a link to your little game, and there it was! And if you wanted it on desktop, you had Adobe AIR!

This one simple fact, for me, overrode all of its downsides (which were legion).

I loved Flash because it was easy to use, it seamlessly merged the visual aspect with the programming aspect, and it worked everywhere that I cared about. It was even easy to distribute and had a thriving "minor league" of popular flash portals to which I owe my career. It didn't have a lot of things going for it, but the things it had were really friggin' important. Lest we forget, YouTube as we know it would not have gotten off of the ground until years later had it not been for Flash.

So if I loved-Flash-so-much-why-don't-you-marry-it, why the sudden falling out?

Well, two things:

  • Flash no longer works everywhere I care about
  • I no longer have confidence in the future of the SWF/AIR platform*

*The tools are another story -- there's hope for Flash CC after the Flash Player's demise

And with those two things gone, suddenly all I'm left with are the many, many downsides of the platform. That's why I switched to Haxe/OpenFL.

Why did I switch? Well, two things:

  • OpenFL works everywhere I care about
  • I have confidence in the future of the Haxe/OpenFL platform

But wait!

Doesn't open source have a bunch of downsides? Yes, gosh yes.

Normally this is the part in the article where I immediately dismiss all those downsides in one grand sweeping gesture, but let's not do that, because Policy Debates Should Not Appear One-Sided is a great article and you should read it.

Instead let's talk about that Security vs. Freedom thing.

Open Source software (let's define that broadly as MIT, GPL, or similarly licensed) has the following features:

  • GOOD: Nobody can take it away from you
  • GOOD: You can fix the source yourself
  • BAD: Sometimes you HAVE to fix the source yourself
  • BAD: Usually nobody is paying anyone to work on it

Commercial software has the following features:

  • GOOD: People are being paid actual salaries to work on it
  • GOOD: Company (usually) has an incentive to fix bugs
  • BAD: If company doesn't fix bugs you just have to wait/hope/pray
  • BAD: It can be taken away from you any time

Finding a good help / learning community is entirely dependent on the size of the community. Conventional wisdom suggests commercial solutions have big communities and open source small ones, but it could just as easily be the reverse and depends on the specific software in question, so I'm calling this one a categorical wash.

Anyways, as my contrived example masterfully shows, open source focuses first on freedom -- "nobody can take this away and you can do what you want with it" -- whereas commercial software focuses first on security -- "this gets the job done and you don't have to get your fingernails dirty". If you're happy with the notion that you might have to move to a new engine in a few years in exchange for enhanced productivity right now, then go for it.

Personally, I take Ben Franklin's aphorism to heart -- that if you trade away too much freedom for security, you'll get (and deserve) neither. But before I nail that point home, let's step back.

How much Freedom and Security do you really need?

These debates get so fired up because we come at them with such divergent values. So let's talk about why I happen to value freedom more than security, and if your values are sufficiently different you don't even need to disagree with me because our purposes are already orthogonal.

If, however, you're coming from a similar sort of place as I am, I strongly urge you to look into Open Source solutions.

Value 1: Don't Take My Stuff Away

So, some commenters snarkily replied to my tweet about how proprietary software is prone to being purchased, abandoned, or neglected with, "Yeah, because Open Source software never gets abandoned," which is fair but ultimately misses the point I was trying to make.

For instance, Defender's Quest was written in Flash, but it did so using the open-source Flixel framework. It's founder, Adam Saltsman, has since moved on to other things, and although there's a community fork, it hasn't been updated in a while. So the original Flixel could probably be considered "abandoned," or at least experiencing a low-key retirement playing canasta.

However, some enterprising hackers picked up Flixel, ported it to Haxe, and re-released it as HaxeFlixel, a robust, mature, and actively maintained game engine that I'm currently building Defender's Quest 2 with. Now, not every open source project is going to experience this, but my point is that there was no one to stop it from happening.

In fact, before I found HaxeFlixel, I was fully prepared to port AS3 Flixel to Haxe all by myself. I wouldn't have done nearly as good a job, but I could have done it. I value technology that always has a way forward, even if I have to pave that road myself.

Now, if you're a developer who doesn't like to have to touch the code of your own foundational technology, than clearly this is a deal-breaker for you, and you should pick whatever the most stable and well-maintained thing is, whether that's commercial or open source.

But just having access to the source makes a resurrection possible.

That said, something doesn't have to be fully Open Source for you to get source access. Take Unreal Engine, for example. If you license Unreal engine, you get the full source! So if there's a bug, and the Unreal team is dragging their heels, you can fix it yourself, or even better, some other community person smarter than you will probably do it first and submit it.

Seriously, Unity users, you should bang on the walls demanding this, even if you never mean to touch the code yourself.

I mean technically in a proprietary-with-source-access world you're still contributing capital back to the capitalist rather than building value for yourself and your community, blah blah, but it's still better than renting a black box you can never open whenever it breaks.

Value 2: Investing For the Future

I want things not just for today, but for tomorrow and for the future. I've often heard people say, "Why are you so fixated on not having to throw all your code away and start from scratch every 5-10 years? Just get over it." To me that's kind of like saying that we should also be accustomed to all the mass layoffs that keep happening in the tech industry (specifically the ones that are based on pointless restructuring and hiring-some-of-you-back-but-over-here-now-maybe rather than "oops we screwed the pooch and we can't afford to pay anybody anymore").

Obsolescence happens now and then and that's just a fact of life, but not all of it is necessary, and it's undeniably traumatic. If our stuff just kept working and getting better rather than spontaneously combusting whenever the Moon passes into the Seventh House, we'd all be richer, happier, and more productive.

I mean seriously, you know what's still around and useful? FORTRAN. C. C++. Even though I don't use C++ myself, Haxe sure as heck does, in fact, the long-term existence and ubiquity of C/C++ compilers that work for every damn system under the sun is precisely the reason that a multi-paradigm high-level programming language like Haxe can be so darned useful!

Anyways, here's the summarily plagiarized ECON 101 argument:

  1. "Capital" is yesterday's labor, crystallized as something useful
  2. If you can build Capital for yourself you have a shot at escaping wage slavery.
  3. If your Capital keeps getting yanked away it's hard to do 2.

Now, many people pointed out, "just because it's not supported anymore doesn't mean you can't still use it!" And this is valid. Not only can you still develop for the original NES and the ATARI 2600, you probably should, because it will make you an awesome human being.

That said, technology gets old fast without maintenance. Adobe dropped Linux support for AIR a few years back and it has been an enormous pain point of mine in supporting legacy Defender's Quest builds. Yeah, I could always drop the Linux target, but I shouldn't have to. In OpenFL, desktop C++ Linux builds work just as well as they do on Windows.

And I have every reason to expect that the world is just going to become more crazily multi-platform as things go on. And I wanna make sure I can take my games there, to tomorrow's platforms, without re-writing my code from scratch. Why should I invest my entire toolchain in the next flavor-of-the-month like Apple's Swift just to get locked in to whatever Apple's plans are?

You can still definitely use Game Maker right now and it will be awesome at all the things it is awesome at. That said, one of the chief appeals of Game Maker is that it's been steadily expanding the platforms it works on. Our writer, James, has been using GameMaker for years and was always afraid he'd have to move on to a "real" program if he wanted to target certain platforms, only to find that GameMaker has slowly added those over time and he can stay right where he is. The future's a bit less certain now.

And of course, plenty of people have pointed out that other software has been acquired and turned out just fine (Flash and GameMaker among them, sort of). But this denies the fact that a corporate purchase is a period of uncertainty. Sure things could be fine, but that's the key word -- could. Hope for the best. Prepare for the worst.

Right now I bet a lot of people would love to fork Game Maker and continue its development as a community, but that option is not on the table. When Oracle bought Sun Microsystems, went along with them, but because it was open source the community forked it as LibreOffice which lives on today. We have no such option for GameMaker, other than rebuilding it from the ground up, which is both legally fraught (thanks ambiguous and overreaching IP laws!) and also a lot of work.

For instance, XNA was just quietly euthanized rather than released as open source. There's MonoGame, which is a great effort, but it's not a drop-in replacment for XNA. Think how much better it would be if it could just start on day one exactly where XNA left off, with full compatibility.

Value 3: Freedom IS Security, kinda.

This one's short. Freedom is a kind of security in itself, because there are all sorts of terrible things that can happen without it. For instance, if you're just licensing your software you actually don't have total assurance that you can keep using it even if it's just been "abandoned," because that license can be revoked, or it can expire.

Or the company can just include invasive DRM that randomly trashes all your hard work with aggressive watermarks.

Which program did that again? I forget.

Also, there's plenty of times where software platforms get bought with the express purpose of killing them, though I don't think that's what's happening with GameMaker.

Value 4: I like things that Just Work

Okay, so I am a pragmatist at heart, and Open Source doesn't always score highly in this regard. Sometimes there's regressions, temporary instability, scene drama and forks and schisms and blah blah blah. Maybe you don't have time for that.

But I do, for various reasons. And here's the secret part. A big reason of why I am not just a user of open source software, but also a contributor? I'm not just building this for me. I'm building it for you -- for us.

When I first jumped into OpenFL, there was a lot of stuff going on, wires were sticking out all over the place, the drywall still needed to be nailed down in places, and you had to watch where you stepped. But things have calmed down a lot since then and it's easier than ever before to use the software, where it's nearly as easy as using Flash, and way more powerful. It's not perfect, but it's very good, it's much better than it was, and most importantly, the security/freedom balance is right in my sweet spot.

Plenty of open source projects have reached the sweet spot less adventurous developers are looking for, as well, and I hope to help do the same for Haxe/OpenFL. (To be clear I am a super baby contributor, most of the benefits have come from other people)

If you have similar values to me, you should check out an Open Source alternative next time you look for a new game engine. If you don't, well, you should probably stick with whatever proprietary solution you're working with and just make sure you're confident in the company responsible for it.

Alternatives to GameMaker

Some of you will stick with GameMaker, and more power to you. I hope this turns out alright, sincerely, I do.

For those of you considering alternatives to GameMaker, here's my personal list of thingies. None of them are one-to-one replacements, but all are worth considering:


  1. OpenFL (or LIME) -- I love it so much why don't I marry it
  2. HaxeFlixel -- feature-rich mature game framework built on top of OpenFL (this is what I use)
  3. HaxePunk -- HaxePunk is to FlashPunk as HaxeFlixel is to Flixel
  4. Luxe -- Sven Bergström's very specifically thought-out Haxe game engine thingy. Component based. Alpha, but I hear good things
  5. Kha -- Another cross-platform Haxe engine. I think this one also works with last-gen consoles, which is a plus

Other stuffs:

  1. Stencyl -- commercial, drag & droppy, noob-friendly, cross-platform. Backend powered by Haxe
  2. Godot Engine -- haven't used it but have heard good things

UPDATE: someone just pointed out the Enigma project, which sounds pretty cool and extremely relevant:

ENIGMA, the Extensible Non-Interpreted Game Maker Augmentation, is an open source cross-platform game development environment derived from that of the popular software Game Maker. Its intention is to provide you with a quality game creation tool and a bridge between high- and low-level programming languages. It can be used either through an IDE, namely, its sister project, LateralGM, or through a Command line interface.

Like Game Maker, ENIGMA comprises both an easy to use Drag & Drop system as well as its own programming language. This programming language, known as EDL, is essentially a mix between C++ and Game Maker's GML. Part of ENIGMA's goal is to remain backwards compatible with Game Maker, serving for some intents and purposes as a Game Maker compiler, however, EDL offers many very powerful features which simply aren't present in the alternative. Such features include the ability to compile DLLs and other C/C++ scripts right into the program and access C++ types, templates, and functions.

Although EDL adopts GML's very lax syntax in its scripting, the inputted code is actually parsed and translated into valid C++. This compilation improves size and performance of the language by incredible amounts, while almost magically maintaining its simplicity of use.