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.

GDevelop

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.

Godot

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.

jMonkeyEngine

According to its marketing material, jMonkeyEngine is a "cross platform game engine for adventurous Java programmers" [4]. The engine proper only makes it possible to create 3D games and is written completely in Java. Supposedly, the use of Java results in rather slow applications.

The jMonkeyEngine makers promise "high performance 3D games that are on equal footing with every other engine." If you want to convince yourself that this is true, you can take a look at games like Bang!Howdy [5] or Grappling Hook [6], which are created with the jMonkeyEngine.

The software development kit (SDK) made available by the developers contains the slightly adapted NetBeans development environment [7] in addition to the engine proper. The core of the environment consists of a high-performance code editor that can automatically highlight the source, offer automatic code completion, and provide a small reference for each function which appears when typing (Figure 8).

Figure 8: A slightly expanded version of NetBeans supplies the development environment for jMonkeyEngine.

Additional functions include source code cleanup or refactoring, a debugger, a profiler, and a connection to the version control systems Git, Mercurial, and Subversion. The development environment also supports the translation of games into other languages. To expand the functionality, you can use all of the available NetBeans plugins.

Games that are created completely in Java run on Windows, Mac OS X, Linux, Android, and on the Ouya console. In the coming 3.1 version, jMonkeyEngine is supposed to support iOS and VR glasses like Oculus Rift. A game can be exported as a JAR archive or in the form of an executable program in Windows, Mac OS X, and Linux.

When developing games, you are primarily working with the source code directly. In comparison to the competition, the development environment offers only a little bit in the way of programming assistance. For example, an assistant imports 3D objects created in Blender, which can then be arranged in a very rudimentary visual editor into a complete scene (Figure 9). The jMonkeyEngine creators recommend Blender as the preferred modeling tool. The development environment also imports Ogre and Wavefront objects.

Figure 9: 3D objects are arranged in the jMonkeyEngine SDK in the rudimentary scene composer. The properties of the selected objects appear in a table on the right-hand side.

Similarly to Godot, you can add individual 3D objects to a scene via nodes. You can arrange the nodes in a hierarchy that makes it possible to build relationships among the 3D objects. The material properties of the 3D objects come from a programmable shader, as is the case in Godot as well. If needed, a component named TerraMonkey can create a 3D landscape from an image with a topographical map or Highmaps.

The jMonkeyEngine simulates a wide variety of light sources. Techniques like screen space ambient occlusion (SSAO) conjure up realistic shadows onto the screen. Moreover, jMonkeyEngine offers a wide array of special effects such as a particle system, a smoke and water simulation, and light reflection. Post-processor filters act on the displayed scenes and create effects like fade outs at the end of a level. The jMonkeyEngine supports keyboards, joysticks, and touchscreens as input devices.

You can create menus and configuration windows with the NiftyGUI Java library [8]. This comes with jMonkeyEngine for constructing the user interface via XML markup or Java code. A Java port of the popular Bullet library, jBullet [9], controls physically correct process flows. It also allows for ragdoll physics, which is the correct movement made by body parts when in motion.

You can test the source code for your games with the accompanying jUnit framework. You can translate the code with the MonkeyBrains Engine that was developed in a separate project [10]. Thanks to the BSD license, every developer is permitted to adapt the source code for jMonkeyEngine as desired for use in commercial projects.

The documentation consists of an extremely large and well-organized wiki, which contains tutorials for beginners and detailed articles for advanced programmers. Several books are available, and an open forum can also clear up questions.

Conclusion

GDevelop lets even the non-programmer create simple games. In fact, you can click together an entire small action game inside an hour. This GCS is suitable therefore for quickly building prototypes. Game developers are limited to relatively simple 2D games. Furthermore, the lists of events and actions can easily get messy.

Godot is well suited for both 2D and 3D games and is similar to the popular Unity 3D, a commercial game platform (see the "Commercial Competition" box). However, with Godot, you will need to learn its scripting language, which should be fairly straightforward especially for Python users. The functionality is greater than that of GDevelop but does not approach that of jMonkeyEngine.

jMonkeyEngine targets experienced Java programmers and has many well-known standard components like the Bullet Physics simulation. If you have not yet worked with NetBeans, you will first have to work your way into the complex development environment or forego its help and integrate the engine directly into your program. The project gets high marks for its extremely comprehensive documentation.