Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
2 contributors

Users who have contributed to this file

@vnen @fire
118 lines (70 sloc) 7.42 KB

Google Summer of Code 2020

This is a list of project ideas for students applying to the Google Summer of Code program in 2020 (GSoC 2020).

It's only an indicative list, and is subject to change as Godot is very actively developed by hundreds of contributors. Use this list as an inspiration source, but feel free to come with your own ideas on what you would like to work on in Godot.

As a complement, you can check out the community proposals repository and fish out some good ideas for projects. You can also engage the discussions over there.

Make sure to discuss your ideas with Godot developers on the #godotengine-devel IRC channel (Freenode server), so that we can help you refine your ideas and ensure that they fit in the Godot roadmap and architecture.

Improve Godot's theme editor

Skills: C++, (potentially) GDScript

Godot's theming system is straightforward -- it is still a game engine ;). This system makes editing themes very easy to understand and results in very little complexity.

However, Godot's simple system comes with a cost.

Although, in Godot Engine styles cascade through child nodes, this is not easily understood. There is also no shared variables.

The goal of this project is to design a theme editor. The theme editor generates a theme with systems, like a color palette, so that we get the best of both worlds. We are combining Godot's simple theming and an advanced theming structure when setting up a theme using the theme editor. There is a significant amount of freedom and space for creative ideas to make creating themes a pleasure while still keeping the core architecture as simple as possible.

A related task is to improve some aspects of the editor theme.

A task such as caching icons for faster startup time, use color icons with modulation (looks better on a light theme, not re-rendering icons when changing from dark to light), and more.

Improvement in i18n for games

Skills: C/C++

Godot uses mainly a special CSV format for the game translations. This format is not particularly good when dealing with the differences between languages, like pluralization rules and order of words in a sentence. While it also supports PO files from gettext, the format is not fully used and not well-documented.

The proposal here is to amplify the abilities of Godot's translation server and add a better support for PO files. The idea is to include the generation of POT (translation template) files from the project, so they can be used with a translation tool to generate the PO and MO files. The addition of support for MO files is needed since it is a binary format that improves parsing performance and reduces size.

The addition of a more specialized translation library can be considered if it's small, has a permissive license, and has a feature-set adequate for game-making purposes.

Additionally, if a different format is available that better handle i18n features, a proposal for supporting it can be considered.

Related links:

Improving VCS integration

Skills: C/C++, Git, Perforce

The initial project to integrate VCS (Version Control System) into Godot was made by 2019 GSoC edition (see pull request #31461). It was a great initial effort but there are many things still to be improved.

For example, here's a list of nice needed improvements that will be great to have:

  • Extend VCS API to support pushing to Github repositories from the editor (see #32665).
  • Build more UI hooks in the VCS API to better mimic most text-editor VCS interfaces like in VSCode (with the source control tab). This includes showing a list of older commits and their details in the editor.
  • Making the diff appear as a comparative list rather than a traditional command-line output for git diff.
  • Adding colored gutter highlights in the text editor to display modified changes, additions, and deletions.
  • Implement the VCS API for Perforce as a plugin using GDNative. This would require little to no research except for searching for a compatible Perforce C++ library (such as https://www.perforce.com/manuals/v15.1/p4api/chapter.overview.html).

Implement the patch system in the export dialog

Skills: C/C++

The export dialog has a "Patches" tab but it doesn't do anything as the backend wasn't implemented.

This project consists in implementing the feature where you can provide the PCK files from the previously releases and export only a patch with the differences. This can be used to release incremental game updates without providing the assets from previous version, making them smaller.

Generate documentation for GDScripts and show them in the Editor interface

Skills: C/C++, XML, GDScript

Documentation in-engine is very useful but currently it's only available for C++ classes. The idea is to also allow scripts to provide documentation that could be read by the engine and be shown in the editor.

The editor uses XML for documentation, so it's likely that such format should be used by this system. It must be read at runtime as well, to account for user-made changes while the editor is running (currently it only does this while compiling).

Related links:

Custom perfomance monitors

Skills: C/C++, GDScript

The performance monitors available in Godot are good to measure the overall performance of your game and find bottlenecks.

Sometimes the bottleneck might be in your code, so usually you have to make benchmarking snippets to see if the code is running too slowly.

This project consists in implementing and exposing and API to allow scripts to add new graphs in the debugger performance tab. The editor will also have to be adapted to allow those custom monitors to be added and removed properly.

Related links:

Improve Visual Scripting

Skills: C/C++

Google Summer of Code 2019 made significant improvements in Visual Scripting / GraphEdit. However, Visual Scripting is still hard to use in the programming and visual shader contexts.

The essential missing feature in Visual Scripting is the ability to collapse a selection of nodes into a function, expand them and then store them in an accessible function library. This function library is retrievable as a resource to be shared in plugins and the current project.

Some other possible improvements to Visual Scripting are:

Allowing scaling a Graph Edit system so that developers can work on more massive graphs.

As Visual Scripts / Visual Shaders become more complicated than previously, it would be beneficial for automatic graph formatting/graph reorganization.

Solve high priority issues in the Godot Engine issue tracker related to Visual Scripting.

Related links:

You can’t perform that action at this time.