Comparing game development environments

Slashdot it! Delicious Share on Facebook Tweet! Digg!
wajan, 123RF

wajan, 123RF

Fun Zones

GDevelop, Godot, and jMonkeyEngine simplify game programming with pertinent libraries, game engines, and developer tools. They make it possible for both beginners and advanced programmers to create nifty games with minimal effort.

Users who would like to develop games in Linux can choose from numerous specialized libraries, frameworks, and development environments. The three game creation systems (GCSs) described here contain everything that both beginners and advanced programmers alike need to quickly create a game that will run on various operating systems.

All you need to do in the development environments offered by GDevelop, Godot and JMonkeyEngine is to import a few graphics, arrange them to your liking in a level, then write some program code with a very convenient editor. Then, as a final step, you create the game with the push of a button. Programming is made easier by virtue of a special library called the Engine. It drastically simplifies the output of images, sounds, and animations as well as network communications. These three systems let you produce an integrated package and create arbitrary games; however, each has its own set of disadvantages.


If you want to create a game but you don't have any programming skills, then GDevelop is a good choice [1]. The development environment constructed by the French developer Florian Rival lets you click a game together with your mouse (Figure 1). GDevelop creates only 2D games in which the graphics output on the screen run on the 3D interface OpenGL.

Figure 1: The user interface for GDevelop has a very clean appearance. The individual functions are collected in the registry at the upper edge in a ribbon framework. The example shows the construction of a racing game.

Once you are in the development environment, you should start by importing 2D graphics to use later to put together a complete scene. You can specify the game sequence by matching important events like "left mouse click" with suitable actions like "move object space craft 10 pixels upward" (Figure 2). The events can be linked via simple conditions (e.g., a logical or ). Actions repeat via loops. If necessary, you can encapsulate the procedures that come out of these steps as functions for later reuse.

Figure 2: You can build the logic just by clicking around in GDevelop, but this can lead to confusing procedure plans even with smaller games.

You can distribute graphics across various layers and place them on top of one another like slides. This creates the parallax effect in which objects that appear far away glide across the display screen more slowly than objects that appear to be closer. Additional functions come in the form of extensions. In this way, you can obtain functions including a physics simulator, an automatic opponent tracker for opponents, and a particle system as well. The latter function provides effects like flying sparks and dramatic explosions. You can use the tile map to produce larger game fields by putting tiles together.

You can use GDevelop to create programs for Windows, Mac OS X, and Linux. Additionally, the development environment allows for exporting the game as an HTML5 application, which runs in every browser. The only issue here is that you must decide from the beginning between a native and a web application. The choice you make determines which extensions will be available. For example, HTML5 games have to do without the particle system. However, they can make use of touch screen and multitouch gestures. When generating native Linux games, you can make use of a debugger and a profiler (Figure 3). The profiler lets you track down performance problems and excessive processor load. The Engine comes with the MIT license and the development environment itself with the GPLv3.

Figure 3: The profiler in GDevelop displays the game performance. The higher the peaks, the slower the car race will run. The debugger lets you temporarily stop the program.

To date, GDevelop mainly has been used to make small freeware games like Blazing Inferno of Space [2] – a game that is well worth playing. The documentation consists of an English language wiki, which is somewhat verbose but also full of tutorials for beginners. Additionally, the development environment offers countless examples of games. Among these is the car race from Figure 1. There is a joint forum for developers and users that answers open questions.


In February 2014, the Argentinian OKAM studio published the complete source code for its development environment, which it had been using exclusively for its own games. Although Godot software had already been in use for several years, it advanced to Version 1.0 in that same year. Further open development is taking place on GitHub under the MIT license; the sponsor continues to be OKAM Studio [3].

Godot contains a 2D and a 3D engine that you can use simultaneously in a game (Figure 4). The display formats can also be mixed, making it possible to do things like place a 3D figure in front of a painted 2D background (Figure 5).

Figure 4: Thanks to its two separate engines, Godot makes it possible to develop 2D games.
Figure 5: Godot also makes it possible to develop 3D games that don't look so rough. As an example, Godot offers the Jump and Run game displayed here.

As with GDevelop, the first thing you should import into the development environment are graphical objects that you can arrange in individual scenes. The objects form so-called nodes, which the game programmer arranges into a hierarchy. A house, for example, would be built out of a roof and four walls. The concept takes some getting used to, but it simplifies the reuse of objects and makes it possible to automate some things. For example, the programmer does not need to separately make each wheel move continuously.

The individual parts of 2D figures, such as arms and legs, can be attached to one another and animated. This would be similar to the animation used in the TV series South Park , for example. Additionally, the particle system can produce nice explosions and other effects. The individual graphical objects should be organized as needed into layers, which permits parallax scrolling. Using a tile map editor, you can also quickly build 2D levels from individual tiles.

The 3D engine can import ready-made models from popular graphics programs, for example, from Maya and Blender. Godot supports animation techniques such as Skeleton Deform and Blend Shape , which can be used to create things like realistic lip movements. Numerous graphics effects are also available. Among these are simple shadowing with Shadow Maps , antialiasing, HDR, blurring effects, and a fog simulator. You can let appropriate mini programs, the so-called shaders, create the material properties of the 3D objects.

The 2D and 3D engines have separate physics simulators and collision recognition, both developed by Godot makers. The game developer will not need to learn anything new. Instead, it is possible to speak to both systems from the same interface. Furthermore, Godot animates all properties of an object across time. This means that the modifications can be precisely controlled on a timeline using key frames, and Godot computes the changes between two key frames. This concept will be familiar if you have ever worked with Synfig or some other animation program.

Godot offers many pre-assembled buttons, sliders, and lists for creating a user interface. You can adapt the appearance of the control elements with skins. Godot also supports game localization, but you will need to deliver translations in your own text files. If these possibilities still don't meet all of your expectations, then you can expand the functionality of the engine with a C++ interface so it can do things like execute time-critical program code separately.

The program logic of the game is programmed in Godot's own scripting language called GDScript (Figure 6). The code editor offers syntax highlighting to highlight the source code and other things. It also automatically suggests key words with code completion. Game execution can be stopped at targeted points by setting breakpoints in the code. If desired, the integrated debugger can jump from command to command and show current values of all variables with a simple key press. The performance analyzer delivers information about memory and processor load, which can be used to optimize the game. Godot can connect to version control systems such as Git and SVN.

Figure 6: The GDScript language from Godot is very similar to Python and indicates nested code blocks with indentations.

The games created with Godot run on Windows, Mac OS X ,Linux, iOS, Android, PlayStation 3, and PS Vita. Both of the latter platforms require an expensive license from Sony. An export feature for HTML5 and Windows phone is currently under development.

At press time, version 1.1, which has a completely overhauled 2D engine, an improved car-building feature in the code editor, and a visual shader editor (Figure 7), is the latest release. The documentation for Godot has many gaps and is available as a GitHub wiki. This documentation consists primarily of a series of tutorials.

Figure 7: In the new Godot 1.1, the shader is described via nodes instead of with the simplistic shader language found in the earlier version.

Buy this article as PDF

Express-Checkout as PDF

Pages: 6

Price $0.99
(incl. VAT)

Buy Ubuntu User

Get it on Google Play

US / Canada

Get it on Google Play

UK / Australia

Related content