GDevelop and Google Summer of Code

Google Summer of Code is a global program focused on bringing more student developers into open source software development. Students work with an open source organization on a 3 month programming project during their break from school.

In 2020, GDevelop was one of the mentoring organisations. We're candidating to be an organization this year too. If you're a student and interested in working with us, read on!

Results of GSoc 2020 projects will be written on this Result page.

Ideas list

Those ideas are not exhaustive. Feel free to suggest your own idea! Or combine ideas into your own. The descriptions are generic enough so that you can suggest different approaches, goals and stretch goals. Mentor(s) are available for all ideas listed already.

Improved Debugger and Profiler

GDevelop has a debugger and profiler that can be used when previewing a game. The debugger can list the objects, expose things like variables and allow to edit them. The profiler can measure the time for each part of the game. Both are still quite raw, so we could improve the UI to make it easier to filter objects, add export/import of data, show information in real time, show charts…

  • Outcome: debugger and profiler with improved features.
  • Skills: React.js (for the editor), JavaScript (for the engine), WebSockets (communication between editor and games)
  • Difficulty: Easy

Refactored collision and object positions handling

A dedicated module to handle object position and collisions (as well as raycast and other algorithms) was started in this PR: (the idea is to be able to port this module to WebAssembly in the future - this can be a stretch goal). It's not finished though: the project will consist in finishing the implementation, check the performance, the integration in the game engine and adapt the extensions (Pathfinding, Platformer, Lights) to use it.

  • Outcome: The module handling object positions and collisions working inside the game engine with good performance
  • Skills: JavaScript
  • Type: Exploratory
  • Difficulty: medium

Allow to edit tilemaps directly in the editor

Tilemap was one of the most asked feature by users. It was recently added but users need an external program (Tiled) to edit maps. Instead, it would be nice to create the object in GDevelop, then be able to draw the map directly in the scene editor.

  • Outcome: a “Tiled Map” object where we can select tiles and draw them on the screen in the scene editor.
  • Skills: JavaScript
  • Difficulty: medium

Refactored and faster code generation

Code generation is a very important point in GDevelop. This project would rework the code generation of events to make it clearer, faster and unlock potential new features like improved object handlings to avoid unnecessary work and get runtime performance boost. This can be seen as a work on a lightweight compiler - which can be fun to then later work on larger ones!

  • Outcome: better generated code in games, faster code generation and performance.
  • Skills: C++ (mandatory to dig into the existing codebase), JavaScript (for the generated code), good understanding of algorithms and data structures.
  • Difficulty: medium

Support opening multiple projects or multiple instances of the editor

Rework the editor so that the user is not forced to close a game before opening another one in the editor. This could either take the shape of another, separate editor window. Or maybe we can keep everything in the same window and have the games share the project manager and share the same list of tabs.

  • Outcome: Support opening multiple games in the editor without closing the current project.
  • Skills: JavaScript, React, Electron
  • Difficulty: Medium (good React knowledge)

Reworked variables editor

When editing global, scene or object variables, the list shown is working ok but can be a bit sluggish when there are a lot of variables. It's also not easy to move around variables, they can't be dragged like actions or conditions in events. This project would make the editor faster and show the variables in a way where they can be reordered and edited easily.

  • Outcome: A faster variable editor (when lots of variables shown) where it's easy to edit variables, add, remove and reorder them.
  • Skills: JavaScript, React
  • Difficulty: Medium (good React knowledge)

Asynchronous actions ("wait action")

Right now, actions that are used in the events editor are translated to a function call (or multiple function calls for objects). These functions are synchronous, they return immediately and the game can't continue while they are not finished. For some actions, it makes sense to run them, then continue the game and come back to execute the next actions (and sub events) when the action is finished. This can be the case for an action launching a network request for example.

  • Outcome: An option to make actions asynchronous, that will generate code that allow to continue processing the actions when it's finished. Also at least one “wait” action that can be used to pause the event for X seconds.
  • Skills: C++ (for the code generation) and JavaScript (for integrating in the editor). Knowledge of React is a plus to implement the changes in the events editor - but this is not a lot of work.
  • Difficulty: Medium-hard

Classify scenes, objects and any list using virtual folders

In large games, there can be dozens of scenes, hundreds of extensions and objects. It would be interesting to allow each of these to have user defined tags and virtual folders. Right now, users can only reorder items in a list.

  • Outcome: a reworked React component to display list of scenes, extensions, objects, object groups and other lists using a “tree view”, where items can be organised, maybe drag'n'dropped, into folders or tags.
  • Skills: JavaScript and good knowledge of React.
  • Difficulty: Medium

Improve the UI for the collision editor

Currently the “collision mask” (also called “hit box”) editor is a bit cumbersome to use. The goal is to make it easier to use predefined shapes, maybe create circles (and possibly add the possibilities to make concave shapes). We should also add a toggle button on the scene editor to render collision shapes.

  • Outcome: a reworked collision editor and the ability to display hitboxes in the scene editor. Bonus: be able to edit hitboxes directly in the scene editor (but this is a stretch goal).
  • Skills: JavaScript and good knowledge of React.
  • Difficulty: Easy-Medium

Animation support for 9 Panel Sprite and Tiled Sprite objects

These “Panel Sprite” and “Tiled Sprite” objects can't be animated. We'd like to remove this limitation by reworking the game engine so that they can be animated, and rework their editors so that animations can be authored and set up like for sprites. This will allow for nice effects like animated platforms, background, lava floors… This will involve refactoring the animation classes in the game engine and refactor animation components in the editor codebase.

  • Outcome: support for animations in the game engine (Pixi.js) for Panel Sprite and Tiled Sprite and updated React editors for them to support creating animations.
  • Skills: JavaScript (Pixi.js knowledge is a bonus) and React.
  • Difficulty: Medium

Advanced tabs and toolbar handling

It's important for users to be able to customize their workspace. This project would work on ideas to make tabs more customizable: being able to drag them, and being able to group tabs together and/or group automatically the scene editor and events sheet tabs of a same scene… and persist these preferences. The toolbar is also for now fixed in the top right. We could make it customizable: position, buttons to display, etc…

  • Outcome: analysis of improvements to the tabs and toolbar, and implementation of these. At minima, the ability to drag tabs, pin them and persist the changes in the preferences.
  • Skills: Good knowledge of React.
  • Difficulty: Easy

Your own idea

Your own ideas and variations on the existing one are very welcome! Remember to take a look at the roadmap if you want to know more about what users are asking for.

How to candidate?

You'll need two things!

  • First, become a bit familiar with GDevelop by solving or working an issue (or adding a simple new feature) on the GitHub Issue Tracker. Take a look at the Good First Issues.
    • You'll need to set up your development environment 💻. The README will explain everything! We're not explaining too much here because it's up to you to search and see how to do. It's not difficult ;)
    • Find an issue that looks interesting to you. Might be a Good First Issue or another one.
      • Do some research, try things, and if you need help ask on the forum or on the GitHub issue itself. Only do that though after searching the problem for a bit (we won't answer to questions to get started as there should be all explained in the README… but in case of doubt - ask!)
      • If you have something interesting, comment on the issue or open a Pull Request! Prepare it with all the required tests and checks, explain what you've done and a reviewer should give you some feedback.
  • Searching to solve an issue is a good first step that will actually help you in the second part: making a proposal!
    • Read the section about how to make a proposal on GDevelop page on Google Summer of Code website 🙇‍♀️.
      • Prepare your proposal on the Google Summer of Code website 🤓. While it's ok to ask questions about GDevelop development on the forum or on GitHub if it's related to an issue, we won't directly proofread or review your proposal. We can answer specific questions about the codebase, but the proposal must be coming from you.
      A good proposal will show that you understood at least the big principles and are able to dive more in the problem. Read also this thread.
Again, make sure to get familiar with GDevelop first. It's a good idea for you to try already to code and contribute to GDevelop! This will help you to understand the codebase and make a better proposal. Read and try some issues in the list of Good First Issues on GitHub.

Frequently Asked Questions

Where can I talk with others about GSoC? What are the communication channels?

Check out the forum section about GSoC. You can send an email (find it on the GSoC organisation page) but all the information should already be there. You can also talk to the GDevelop community members on the Discord GSoC dedicated channel.

For student(s) that will work on GDevelop during GSoC, we'll have regular catch-up by email, using GitHub and sometimes by video call.

Should I reach out to the forum, by email and on the Discord chat to have my proposal considered?

No. Your proposal will be considered in all cases. It's a good idea to engage with the community on the Discord or the forum if you want to know more how GDevelop works. Looking at “Good First Issues” and trying to fix/improve stuff on GitHub is highly recommended for you to have a better idea of how GDevelop is coded before making your proposal.

Should I include my participation on the forum/Discord/GitHub in my proposal?

Yes, it's a good idea, if you participated or contributed already to GDevelop, to include it in your proposal so that we know what you did already - especially useful to give us more confidence in you being able to achieve the project 👍