GDevelop is a great open source, free game engine that allows anyone to create games without coding. It has a visual interface and events system that makes game development accessible even for total beginners.

However, there are some useful tips and tricks that can help you take your GDevelop game creation to the next level. In this guide, we will share 10 GDevelop tips and tricks that you might not know about, especially if you’re just starting out with this engine.

Contents: 10 GDevelop Tips that you might not know of!

1. Use the Ctrl key to duplicate objects quickly

When you’re building a scene in GDevelop and want to add multiple instances of an object, the normal way is to keep clicking on the object in the resources panel. This can get tedious very quickly.

A little known time-saving trick is to hold the Ctrl key and click on the object to instantly duplicate it. Here’s an example:

Normal method: Click on Key object 4 times    Faster method: Click on Key object once Hold Ctrl and click 3 more times to duplicate 

As you can see, the Ctrl+click method is much faster for adding multiple copies of an object. This tip can save you a lot of time, especially when working on large scenes.

Pros of using Ctrl+click:

• Faster than normal clicking
• Easy way to duplicate multiple objects
• Saves time when building large scenes

Cons of using Ctrl+click:

• Sometimes you may duplicate accidentally
• Needs getting used to at first

2. Use instance variables to reduce duplicate objects

When making similar objects like coins, enemies etc in GDevelop, it’s tempting to just create separate objects for each instance. Like Coin1, Coin2, Enemy1, Enemy2 etc.

However, a better way is to use instance variables. Set a variable like “type” or “color” for each object instance.

For example:

Object: Coin Instance 1 variables: type = "Bronze"   Instance 2 variables: type = "Silver" Instance 3 variables: type = "Gold" 

This keeps the object list clean and organized. No more duplicate objects!

Pros of using instance variables:

• Reduces duplicate objects
• Keeps object list clean
• Easier to manage than individual objects

Cons of using instance variables:

• Need to manually set variable for each instance
• More work if you have many objects

3. Use the Resource tab to remove unused objects

When developing a GDevelop game, it’s easy to end up with a lot of unused objects, scenes, sprites etc sitting in your resource folders.

To optimize game size and loading times, make sure to remove any unused resources before you build the game.

You can do this from the Resource Manager > Resources tab:

• Right click and select “Remove resources with invalid path”
• Right click again and select “Remove unused resources”

Doing this cleanup regularly ensures you don’t ship any unnecessary bloat in your game.

Pros of removing unused resources:

• Reduces game file size
• Speeds up loading times
• Good optimization practice

Cons of removing unused resources:

• Have to remember to do it manually
• Need to be careful not to delete resources still being used

4. Take advantage of built-in extensions

GDevelop comes packaged with tons of handy extensions that add extra behaviors and functionality to the engine. You can access these from the Extensions tab in the editor.

Some really useful extensions include:

• Sliders: Lets you add sliders for adjusting variables
• Flash: Makes objects flash on and off
• Particles: Built-in particle system
• Progress Bars: For health bars, loading bars etc
• Advanced Sprite: Animation and sprite sheet support

Before trying to code complex behaviors, check if an extension already exists. You can save a lot of time by taking advantage of these built-in tools.

Pros of using extensions:

• Avoid reinventing the wheel
• Save time on common behaviors
• Supported and updated regularly

Cons of using extensions:

• Can get overwhelming with too many
• Need to learn how to use each one

5. Use the mini instruction selector

When adding conditions and actions in GDevelop events, you normally have to go through the full instruction selector dialog.

A quicker way is to right click directly on the condition or action text. This brings up a mini instruction selector right in the event window!

For example, right click on “Condition: Collisions” > Select new condition. This avoids opening the full selector popup.

The mini selector is great for quickly editing existing events and adding new instructions on the fly.

Pros of the mini instruction selector:

• Faster editing of events
• Avoid opening full instruction selector
• Convenient inline adding of conditions/actions

Cons of the mini instruction selector:

• Only shows instructions for selected object type
• Less discovery of available instructions

6. Sort objects in the Instance panel

The Instance panel in GDevelop displays all instances of objects in your scene. You can sort the objects by clicking on the headers:

• Click X to sort by horizontal position
• Click Y to sort by vertical position
• Click Layer to sort by layer depth
• Click Angle to sort by sprite angle

This provides a quick way to organize objects without having to manually move everything.

Some examples where sorting helps:

• Sorting enemies from left to right
• Stacking objects by depth layer
• Organizing UI elements by vertical position

Take advantage of the built-in sorting to save time arranging objects.

Pros of sorting instance objects:

• One click sorting
• Alternative to manual rearrangement
• Sort on multiple properties like X, Y, Layer etc

Cons of sorting instance objects:

• Unintended sorting if clicking headers accidentally
• Objects with identical values may swap positions

7. Trigger events only when needed

Some events like collisions checks and variable updates can happen frequently during gameplay, often multiple times per second. This can impact game performance and FPS if not optimized.

Some tips to optimize event triggering:

• Use timers to check collisions every 0.5 seconds instead of every frame
• Limit variable updates to only when needed
• Avoid pixel-perfect collisions (use circles or rectangles instead)

The key is to trigger events only when needed, and only as many times as absolutely necessary. Good event optimization goes a long way in smoothening gameplay performance.

Pros of optimizing event triggering:

• Improves game performance and FPS
• Important for mobile and slower devices
• Essential for games with lots of events

Cons of optimizing event triggering:

• Requires more planning and testing
• Can be complex for physics heavy games
• Need to find right balance and frequency

8. Avoid using huge image resources

It’s tempting to use very large high-resolution images in your GDevelop games. But large images come at a cost – longer loading times, more memory usage and dropped FPS.

Some best practices when importing images:

• Downsize large images to the smallest dimensions acceptable for your game
• Use compression to optimize file sizes without losing too much quality
• Split large sprite sheets into individual sprites whenever possible

By being mindful of image sizes, you can greatly improve your game’s performance and load times.

Pros of optimizing images:

• Smaller game size
• Faster loading
• Reduced memory usage and FPS drops

Cons of optimizing images:

• Can lose quality if downsizing too much
• Compression can introduce artifacts
• More work to split up sprite sheets

9. Use GitHub for collaboration

For any non-trivial GDevelop game worked on by a team, using GitHub for collaboration and version control is highly recommended.

Here’s a quick guide to get started:

1. Create a free GitHub account
2. Make a repo for your GDevelop project
3. Add team members as collaborators
4. Commit changes and push to GitHub
5. Manage branches for new features
6. Use pull requests to review and merge

This workflow allows all team members to coordinate editing the project without risk of losing work or overwriting changes. The version history also helps revert mistakes.

Pros of using GitHub:

• Enables team collaboration
• Prevents overwritten work
• Maintains version history
• Code review with pull requests

Cons of using GitHub:

• Learning curve for Git basics
• Easy to accidentally commit wrong changes
• Merge conflicts need resolving

10. Optimize Shape Painter objects

The Shape Painter object lets you draw custom shapes, but it can cause FPS drops if overused because it renders shapes in realtime.

A better approach is to use the “Render to Sprite” extension:

1. Install Render to Sprite extension
2. Draw shapes using Shape Painter as usual
3. Add action to render Shape Painter to sprite
4. Display sprite instead of live shapes

This renders the shape drawing into a sprite asset instead of realtime shapes. The performance improvement is very noticeable.

Pros of optimizing Shape Painter:

• Greatly improves FPS
• Avoids performance hits from live shapes
• Lets you reuse rendered sprite

Cons of optimizing Shape Painter:

• Requires Render to Sprite extension
• More steps involved
• Can’t edit shapes after rendering

Conclusion Gdevelop tips

GDevelop is already an excellent open source game engine, but mastering some of its lesser known tips and tricks can help boost your game development skills even further. The small workflow optimizations and performance best practices covered in this guide will give you that extra edge.

Whether you’re just starting out with GDevelop or are looking to level up your skills, keep these handy tips in mind and you’ll be building better games in no time. Don’t forget to share any of your own tips and tricks in the comments below!

I’d love to hear about any other GDevelop tips and tricks you’ve discovered! Share your top tips in the comments section.

If you want to read more interesting contents on Gdevelop then don´t forget to comeback to our blog.