Basic game making concepts: What you need to know to start with GDevelop

The basic concepts of GDevelop are simple. Read the following information to get started with the software. If you don't have GDevelop, download the latest version here.

Showing things on the screen: the Objects

Everything that is displayed on the screen is called an “Object”. Different kind of objects can be used to display different game elements on the screen. For example, most game graphics are “Sprite” objects, texts can be displayed with “Text” objects and special effects like a fire or sparks can be created with “Particle Emitters”.

The wiki page associated with objects can be found here.

Positioning Objects in the world: Coordinates

Objects on the GDevelop screen/scene have X and Y coordinates. These coordinates correspond to the horizontal position (X-axis) and the vertical position (Y-axis) on the Cartesian plane.

The X-coordinate decreases as you go to the left and increases as you go to the right. The Y-coordinate increases as you go down and decreases as you go up.

In order to move or rotate objects, you will need to specify the desired angle in degrees. The illustration below demonstrates how GDevelop understands the angle of rotation:

The below gif shows both of these concepts used within the engine, modifying the X and Y position and rotation of the ship sprite object. Note that the top left corner of your game's default screen, the screen position when no camera movement has been applied, is where X=0 and Y=0.

Note that angles can be negative too. For example, -90 degrees is equal to 270 degrees.

If you use trigonometric functions like the sine or the cosine, you will need to express the angles in radians. (1 radian = 180/PI degrees and 1 degree = PI/180 radians. PI is the number which is approximately equal to 3.14159).


Events, that you use to create the rules of your game, are composed of conditions and actions. Conditions can be thought of as “if” and actions can be thought of as “then”, for the purpose of making things happen in your game. “If” the conditions are true/met, “then” the actions will happen. Most conditions and actions refer to objects:

  • Conditions run a test on the objects.
  • Actions manipulate the object. They can change the object position, appearance, etc…

An event, without any conditions, is treated as if its conditions are true. Therefore, in the gif below, the ship object will rotate at the speed given to the rotate action.

If this event is given the condition “The cursor/touch is on” and we select the ship object for this event, then the action will only happen “if” the mouse cursor is on the ship object.

The wiki page associated with events can be found here.

How objects are selected by these Events

An action, without a condition, refers to all objects. If you use an object for the first time in an event, GDevelop will test or modify all objects with this name in the scene. If you use the object in the same event again, GDevelop will test or modify only the objects which have been picked by the previous conditions.

For example, this event has no condition. It will delete all objects called “Ship”:

The event below has a condition. It will delete only the “Ship” objects with an X position that is less than that of the mouse cursor:

See it in action! 🎮Open this example online:

The wiki page associated with object picking can be found here.

Events: the order is important

The order of events does matter!

Events at the top are executed first. Events are executed every time your game is displayed. This display is called a frame. It executes about 60 times per second. The following examples are not equivalent:

  • In the first image above, the first event creates a “Ship” object at coordinates X: 100. Y: 200 (100;200) on the base layer. Then the next event deletes that created ship immediately. This pair of events Will not display a ship on the screen. It's deleted just after being created.
  • In the second image above, the first event deletes all the “Ship” objects from the scene/screen. It then creates one “Ship” at the scene/screen coordinates X: 100, Y: 200 (100;200) on the base layer. This pair of events Will display a ship on the screen. (before being deleted at the next frame. It will, then, be recreated immediately.)

Behaviors: pre-defined rules and logic for objects

Behaviors enhance an object with some pre-defined logic. They can be reasonably straightforward, automating simple tasks, or much more advanced tasks. For example:

  • A behavior can be used to automatically remove an object from the game when it goes out of the screen (limiting the game memory usage).
  • Another behavior can be used to move objects on the screen with the keyboard arrows.
  • Yet another behavior can be used to allow the object to be dragged on screen with the mouse or by touching the object.
  • The Physics behavior is an example of an advanced behavior which make your objects move in a realistic way, following the laws of physics.

Behaviors will often come with their own variables that can be changed to customize the task it performs, but they can also be manipulated using events that are specific to that behavior.

The wiki page associated with behaviors can be found here.

You can create custom behaviors for your objects. We recommend this as your game grows. It allows you to put logic about what your objects are doing in the custom behaviors, rather than bloating the scene's events sheet. You read more in this article.

Moving objects: using the built-in forces

Moving objects can be achieved with forces. Forces are used to “push” objects.

You can specify:

  • the coordinates of a force on the X and Y axis, in pixels,
  • or its polar coordinates (the force angle, in degrees, and length, in pixels),
  • if the force is instant (will only push “a bit” the object) or continuous (will keep pushing the object until it's removed).


Say you want to move an object to the right or left of the screen.

You can add a force using X/Y coordinates by specifying 50 for the X coordinate and, say, 0 pixels for the Y coordinate. You can also use polar coordinates and add a force with an angle of 180° and a length of 50 pixels.

In the example below, the X position of the ship is used for the conditions to cause it to go in the opposite direction when it passes 200 or 600, along the X-axis.

Other ways of moving objects

Some “behaviors”, like the Physics engine or Pathfinding, may move the objects by themselves. In this case, it is better not to use the built-in forces system and instead rely only on actions provided by these behaviors.

See it in action! 🎮Open this example online:

These other ways of moving objects are explained in this how-to page.

Storing any information in memory: Variables

A Variable allows you to store data. For example, a variable can store a number or a text. We might compare them to drawers or boxes where we can file notes. Any data can be stored in a variable, as long as it is in text or number format. Such things as the number of lives a player has remaining, a player's high score, the number of bullets left, and/or the number of enemies killed are all examples of what can be stored in a variable. You are probably going to store numbers in variables as a common practice.

Actions and conditions test or change a variable value.

Where are variables stored? (variable "scope")

The scope of a variable determines the place a variable can be accessed. In GDevelop, there are three variable scopes are available:

  • Global variables are accessible from all the game scenes. For instance, they can be used to store the player's score across different levels/scenes.
  • Scene variables are only accessible from the scene they are created in. They can be used for data that only concerns one scene. A Scene variable would be able to access the time remaining to complete the level/scene.
  • Object variables only concern one object. For example, a hero can have a “Health” or “Ammo” variable.

The wiki page associated with variables can be found here.

To further expand on how variables can be used in a game, see expressions.

An advanced notion: the "time elapsed" since last frame (TimeDelta)

The game evaluates events and repaints the screen several times per second: we say that the game is refreshed, updated during a “tick”. How often this happens depends on your computer resources: a slow computer can render 25 frames per second, a fast one 60. GDevelop can usually make sure that this value is the same on all computers. However, the speed of some operations can change from computer to computer, for example, mathematical operations and the rendering of movements.

To make the speed of changes constant, use the TimeDelta() expression, which returns the time in seconds since the last frame. For example, don't do this:

But do this instead:

  • The first event is adding 20 to the variable every time the game is refreshed (i.e. as much as possible, up to 60 times per second). It's not correct to use such event as the speed of the increase of the variable will not be the same from computer to computer: we cannot predict the value of the variable after 10 seconds for example - as it depends on the number of frames of the game painted.
  • The second event is correct and reliable : The number 300 is multiplied by TimeDelta(). Thus, the variable will be increased at the same time on all computers. As TimeDelta() returns a time in second, it allows you to quantify exactly the amount: In our case, the variable will grow at 300 units/second. Thus, we can predicate that life will increase by 3000 units in 10 seconds - whatever the number of frames painted during this time.
As GDevelop will run your game at a maximum of 60 images per second, you usually won't notice an issue if you're using the first event. It's still a good idea to keep an eye on this and use the version with TimeDelta() instead.

Rule of Thumb: Use TimeDelta() when you want to continually add some amount to a value. If your action is meant to be launched only once (for example, during a collision where you then delete the object), it's ok to use a discrete value without TimeDelta - as it does not depend on the speed of the game.

When you're moving an object using forces, there is no need to use TimeDelta() as GDevelop automatically uses it.

And... that's almost all you need to know

➡️ You can continue to read the tutorials to know more about creating real games with GDevelop!