Pingudroid: pixels, music, videogames and stuff (and penguins)

A first look into Unity, from the perspective of a Godot user

Hello everyone! I hope you’re well. This past couple of weeks have been a bit insane for me (lots of stuff going on at once!), and today I was planning on writing about music composition, but since I’m currently taking a course on Unity game development, I’ve changed my mind. I’m going to talk engines and, in particular, share my first impressions of Unity, from the perspective of someone who only had previous experience with Godot and RPG Maker.

Now, for a bit of background: I’m a hobbyist developer who has only worked on 2D games so far. After some light modding of Game Boy Color and Game Boy Advance games, I moved on to RPG Maker VX Ace, and after trying out some random free engines, I settled on Godot. I’ve been using Godot as my engine of choice for tinkering for the past five years, started out with Godot 2 then converted my project to Godot 3 and will switch again to Godot 4 when it’s released. I’ve never published any games, I only do this as a hobby for fun.

That said, I wanted to learn Unity because it’s the industry standard and all my local gamedev friends and contacts use it. So I’m taking a (very intense) course on Unity 2D and 3D game development, which I started last week and will last until the end of the year.

For reference, I’ll be comparing the Godot 3 branch to Unity 2019.3.10, and their performance and use on a fairly competent computer (6-core 9th gen i5 processor, 16gb RAM, 4gb GDDR5 graphics card) running a Windows 10 system.

Installation and loading

The first thing I noticed, after downloading and installing Unity, was the sheer size of it: gigabytes upon gigabytes of stuff, which kept piling up if I wanted to install right away the required export templates for different platforms. Comparing it to Godot is almost ridiculous, with its barely 70 megabytes of size plus half a gigabyte for the export templates. The Mono version of Godot takes up more space and has more dependencies, but even then it’s noticeably smaller.

Another fact that I noticed was that setting up Unity isn’t nearly as straightforward as using Godot. Even though Unity is available for free, you still need to register an online account and ask for a license, which you then have to activate in Unity Hub. In comparison, loading Godot is as easy as clicking the portable .exe file right after downloading it, and you’re set to go. However, I’m willing to accept this because Unity is a commercial product and Godot isn’t.

Unity Hub is another extra step that I wasn’t expecting. On the one hand, I think that being able to choose between different Unity versions is great if you’re working on different projects, since it’s recommended to stick to the same version throughout development. On the other hand, I can’t help but find Unity Hub cumbersome, much more so than Godot’s project loader screen, since it takes longer to load and is more bloated. I’d appreciate being able to open a specific Unity version directly, to be honest.

At first I thought that it would be a good idea to implement a loader similar to Unity Hub for Godot Engine, but then I realised that it’s unnecessary. Unlike Unity, Godot doesn’t require an installer and works as a portable program, so keeping and organising different Godot versions is extremely easy. In that sense, Unity Hub feels like a patch to organise a lot of bloated installations, which adds even more bloat to the system.

So, first impression? Not so good, and it kept getting worse when I tried to create a new blank 2D project and it took over a minute (a full minute!) to do so. Even worse: the blank project was 150 megabytes already, before I had even implemented anything, no code, no graphics, no configurations. In comparison, it takes 3 seconds to create a blank Godot project and it’s precisely that, a blank project: less that 8 kilobytes.

And a third thing: Godot opens almost instantly, and Godot projects load in just a few seconds. On the other hand, even the simplest of Unity projects takes over half a minute to load. I don’t even want to imagine trying to use Unity on a lower-end computer.

So, my verdict on installation and loading:

Unity: Mediocre, unintuitive registration process, slow load times and bloated projects.

Godot: Excellent, doesn’t require installation or registration, fast load times and lightweight projects.

User interface

Now, my first impression of Unity wasn’t good, but I was already expecting it to be a quite massive program, and comparing it to a tightly packed piece of open-source software such as Godot might not be entirely fair. So I didn’t let that first impression cloud my experience with it.

At first sight, the Unity interface looked nice, orderly, if a little too bright. Godot has a default dark UI (most programs should nowadays, particularly programs that focus on programming and staring for long hours at a screen), while Unity 2019.3.10’s is light and grey. However, more recent versions of Unity have dark mode available for free users, so this isn’t an issue anymore.

Neutral colors are good when working on visual projects, such as videogames, to prevent them from interfering with the design process. In that sense, Unity’s choice of colors (or lack thereof) in the interface is appropriate. I do think that Godot should go back to its more greyed-out standard palette from Godot 2 and drop the blue, but since the editor has entirely customisable colors, that isn’t much of an issue.

Now, regarding the interface and layout itself, Unity has a quite responsive interface that adapts well to multiple monitors and allows you to easily drag and drop menus and set them up however you like. Godot’s interface is also pretty customisable but not nearly as much, which makes Unity the superior contender in my opinion. I believe that multiple monitor support is in the works for Godot 4, so this shouldn’t be an issue for much longer, but layout customisability is still better in Unity.

Another excellent feature in Unity is the layout preset loader, which lets you easily save and load interface layouts from a dropdown menu. If Godot becomes more customisable someday, it would benefit from something like this. It’s very convenient, since you can have a layout for programming, another for level design and so on.

There’s a few things about Unity’s interface, though, that I found unintuitive and strange at first sight, probably because I’m used to the Godot way. The lack of an integrated script editor most of all: some professional programmers might disagree, but having a powerful integrated editor right inside the engine is very comfortable and convenient for many users. Also, having the game preview window embedded into the interface felt weird. I know it can be moved, but I’m more used to Godot’s way, to simply hitting play and having the window open.

When working in Godot, I feel like I have a more accurate impression of what the game is going to look like when using the editor itself, so I don’t need to preview stuff in-game nearly as often, and work faster. This might also have to do with Godot’s and Unity’s different approaches to canvas and UI design, but I’ll talk about that later.

Godot’s interface feels sleeker because it’s made in Godot’s own UI tools, which are very powerful, and you can customise font size and color, which is definitely a plus for accessibility. On the other hand, Unity has more customisable docks and feels more adaptative.

In conclusion, my verdict on user interface is:

Unity: Pretty good, layout is highly customisable, saving layout presets is useful, theme isn’t very customisable.

Godot: Pretty good, customisable themes make it more accessible, integrated script editor is good, layout could be more customisable.

Node system vs GameObject/Component system

I’ve only been using Unity for a week. Most of that time I’ve focused on learning the interface and the most basic elements required to make games, which would be Scenes, GameObjects and Components.

Now, I’ve read a lot of discussions on the advantages and disadvantages of Godot’s system vs Unity’s system, but I really wanted to experience Unity’s system for myself before I made any judgments. For what I’ve seen, both systems are similar in many ways: you have scenes, each scene contains a hierarchy of game elements (GameObjects in Unity, nodes in Godot), you can attach certain properties to each element (Components in Unity, nodes in Godot), you can save certain game elements as separate files and reuse them in different scenes (Prefabs in Unity, scenes in Godot), and the kinds of properties and game objects are similar: 2D and 3D objects, colliders, animators, UI, etc.

I haven’t worked in 3D so far, but for 2D, both engines seem equally capable. Unity’s system makes sense and it’s pretty usable. The interface for editing, copying and pasting, moving, etc. GameObjects and Components is good, it has a nice file browser, drag and drop is easy, there’s also a good layer and tag system in place, etc. It’s a solid program and I can see myself working with it with no issues, in both big and small projects.

However, Unity’s component system might be good, but Godot’s node system… it’s something else. Definitely its strongest point. Unity has Scenes, Components, GameObjects and Prefabs (and probably more stuff that I, as a beginner, haven’t learned yet). You have to learn several different systems, which are located on different parts of the interface, and make them work together.

However, in Godot, all those different elements are combined into a single one: nodes. Everything is a node. Even scenes are just nodes that are saved as individual files. Need a specific functionality? Add a node. Or a child node. Or a child node of the child node. Each node has its own properties and can only have one script attached to it, which makes for a much more optimised and orderly approach to gamedev than Unity’s, less scatered, more focused. You can nest nodes forever, you can save them as individual files and instance them wherever you like… It’s a conceptual heaven.

So, my (very personal, probably biased) verdict:

Unity: Pretty good, works well, provides all required functionality, easy to learn, good interface.

Godot: Excellent, provides all required functionality in the most abstract, expandable and simple way possible (node system).

UI tools

One of the things that I most often hear people praise Godot about are its UI tools, that is, the nodes and systems used to design windows, buttons and so on. I didn’t fully understand why, until I tried to design a simple user interface with Unity’s default components and I went: “Oh, so that’s why”.

There is no denying it, Godot’s UI design tools are much more powerful than Unity’s. Buttons, popups, graphs, rects, alignment… When I first started using Godot, I barely knew anything about UI design, yet I could get a good UI going pretty easily. Now, after becoming used to the Godot way, Unity’s components feel severely lacking in comparison.

Another thing that really bothers me is the way that Unity renders the Canvas layer in the editor window. For some reason, the canvas can’t be resized and it’s always ridiculously huge, no matter the size of your default camera. This makes it impossible to preview the UI unless you check the game preview window. Very cumbersome, particularly if you want to design a UI that interacts in some way with the 2D or 3D world and they need to fit together.

Another well-known fact is that the Godot UI is made by using the very same system that powers Godot games. So this means that the Godot editor UI has the potential to become truly amazing. I really hope that in the future we get better customisation and panel docking for the editor, because then Godot would definitely blow Unity out of the water when it comes to user experience.

One good point going for Unity are is tools for screen responsiveness. Being able to easily set different screen sizes in the game preview, and also the “anchor” and alignment tools for all Canvas objects, that’s really practical and easier than setting up responsive interfaces in Godot. So far, I think that’s the strongest point in favor of Unity’s UI system.

My opinion on UI tools:

Unity: Adequate, a bit basic, requires lots of tinkering and customisation to get more interesting results, the tools for screen responsiveness are pretty good.

Godot: Excellent, lots of default UI nodes that will do basically everything for you, easily customisable, easy to learn.

Tilemap editor

By now, the “waiting for Godot” line is so cliché that it’s almost cringe-worthy, but it’s true: I have been waiting for Godot… to implement a proper tilemap editor. For years, actually. The current tile editor is atrocious, very unintuitive, with almost no functionality, and is (in my opinion) the weakest point in Godot’s 2D tools, usability-wise.

In comparison, Unity’s default tilemap editor does its job. It’s not perfect or feature-packed in any way (a specific tool like Tiled, for example, is a way better choice), but it has all required tools, it works well, it supports tiles of different sizes and you can easily drag and drop new tiles into it. So I have no complaints.

Fortunately, Gilles Roudière is currently working on a totally revamped tilemap and tileset editor for Godot Engine, which I’m eagerly looking forward to, and will put Godot’s tilemap editor on par with (if not above) Unity’s. Until then, though, Unity’s editor is definitely better.

Unity: Adequate, has all required basic functionality. A specific tool like Tiled is better, but this gets the job done.

Godot: Very bad, creating and editing tilesets is slow and unintuitive and the tilemap editor is extremely basic.

Animation editor and other tools

I haven’t had the time to get much deeper into Unity than what I’ve reviewed here. I haven’t even gotten into programming with C# yet. So far I’ve tried out the animation editor to animate some UI elements and sprites, and it seems pretty intuitive, not much different from Godot’s. However, Unity’s animation editor has the advantage of a “Record” option that records the current state and position of the selected GameObject to the animation timeline. That puts it a step forward in functionality to Godot’s editor in my opinion. Besides that, Godot’s animation editor seems a bit more versatile and easier to combine with scripts and function calls, although I won’t know for sure until I get deeper into Unity’s.

Apart from the animation editor, so far I’ve set up some cameras, colliders, objects and physics in Unity, which work as expected. It’s clearly a polished engine with lots of work and thought behind it.

One thing that I find a bit unintuitive is the difference between global and local positions for GameObjects. I don’t entirely understand the choice to make only the local position visible in the inspector. But it’s a minor setback so far.


After this first intense week of learning Unity, I find that it’s a very solid program and has many perks. However, for the moment I see no reason to recommend it for 2D over Godot. I’m sure that Unity’s 3D tools will prove to be more powerful than Godot’s, when I get to them, but for 2D they’re close contenders, and the fact that Godot is open-source, much more lightweight and has better UI tools and an amazingly expandable node system is a win for me. The only reason to choose Unity is the very same reason why I’m learning it: because it’s the industry standard. But if you can choose, for 2D at least, Godot seems to objectively have enough advantages to make it worth it.

Still, perhaps I’ll write up a more in-depth comparison in the future, after I get more experience in Unity and learn some 3D development. Until then, I hope these first impressions of mine can be of interest or use to somebody.

In the end, choosing one engine or another or neither of the two is a personal choice, and I think both engines have their merits and could be used for different purposes depending on the situation.

My best wishes and thank you for reading!






One response to “A first look into Unity, from the perspective of a Godot user”

  1. Some important lessons I’ve learnt on game development – Pingudroid Avatar

    […] a week into the course, I published an article talking about Unity and comparing it to Godot, which was the engine that I had the most experience with. At that point I didn’t have much […]


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s