Google Summer of Code 2019
This is a list of project ideas for students applying to the Google Summer of Code program (GSoC 2019).
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.
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.
Java and/or Objective C API Wrappers for Android and iOS
Skills: C++, Java, Objective C
Currently, writing wrappers to access code in the Android API is complicated, which makes writing add-ons or binding external modules to the platforms more difficult. For iOS it is a bit less of a pain, but requires Objective C knowledge.
Both Objective C and Java provide introspection APIs (Java does also in C via JNI), which would allow using the entire platform APIs via GDScript.
It would make it much easier to directly support features of each platform that were not directly exposed in Godot, as it would allow calling functions and instantiating classes from the Java/ObjC world without actually needing glue code.
This could be a simple assignature for one student, or two separate ones (for Android and iOS, depending on skill set and familiarity with the platform).
There is an existing, abandoned effort for Android here.
RTL and font shaping support
Support for RTL (right-to-left) languages is unfortunately still incomplete in Godot. While it supports Unicode fonts, without the proper implementation for RTL and font shaping it is not suitable to use with languages like Arabic that requires different letter shapes based on the position in the word.
This project consists in implementing this functionality into Godot, maybe with the help of a third-party library. It should add support for RTL marks and font shaping inside text controls (such as
RichTextLabel). It could also add support for container controls to swap orientation based on a flag (such as
Android template builder
Skills: C++, Java, Android
Currently, the process of exporting a project to Android requires Godot to hack into the APK template to include the game assets, also changing the binary manifest file to replace permissions and custom app information. Besides that, including custom Java modules require recompiling custom templates and adding details in the Project Settings.
This proposal consists in change how the template compilation and export for Android to facilitate the APK generation without the need of special hacks. It requires changing the process to call the Gradle tool on export, making it transparent to the game developer while making it easier to include the custom addons.
This project needs to add an Editor Setting with the Android SDK, detect a special folder with Android template and build with the SDK, show proper build errors captured from Gradle, and allow installation of addons in the special project directory (such as AdMob and Firebase).
Related issues and pull requests: #18865.
Improvement in i18n for games
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.
Animation Motion Matching
Godot 3.1 comes with a new animation tree system which lets you freely edit animation graphs. It would be useful to integrate an extra animation node to create Motion Matching. This technique was developed by Ubisoft for the game For Honor and has quickly been used more and more in the industry.
The proposal is to implement a AnimationNodeMotionMatch node in the new AnimationTree system to handle this workflow.
GDScript Code formatter
Skills: C++, GDScript
The integrated script editor of Godot is a great tool for editing GDScript files, with code folding and auto-completion. However, there's nothing yet to make the code look pretty to the human eyes.
Following this idea, the applicant would work on a set of editor features to define code beautifier rules and apply them automatically to the source code.
Related issues and pull requests: #7392.
Language server for GDScript
Skills: C/C++, GDScript
While the integrated script editor in Godot is quite focused to work with GDScript, it always lacks features found in dedicated editors. Maintaining the script editor takes effort and given the other sources of attention, it's natural that it lags behind. However, special completion features (such as completing nodes in the scene) are not available in dedicated editors, making them not as convenient to work with GDScript.
The idea is to integrate a language server in Godot that communicates with external IDEs, providing the best of both worlds. Currently, Microsoft's Language Server Protocol (LSP) seems to be the leading standard in this regard, having implementation for many languages and editors. The project would be providing a powerful LSP plugin into Godot so it can be used by other editors such as VS Code and Qt Creator.
Related issues and pull requests: #2245.
A threaded and paged filesystem cache
Skills: hardcore C++
On most platforms, the OS takes care of caching filesystem activity and it does its best to serve the wide variety of applications that run on the system. Sometimes however, that's not enough, either because a game will require a specific caching behavior that the system doesn't provide, or because there's no cache at all in the OS. In that case we currently use the
FileAccessBuffered class, which is a nice hack, but not enough.
The objective would be to create a class that manages all the cached content in pages, and provides features such as reading ahead for streamed files, scheduling reads for files that will be needed in the future, queueing simultaneous reads from the same device while threading them from separate devices, etc. Not all features will be finished in one summer, but the basic architecture should he there.
Could be done mostly as a GDNative module, but might require some hooks in the engine core.
Static analyzer for Godot projects
Skills: C++, GDScript
Godot can detect a lot of errors during debug sessions, pointing to missing references or undefined variables. However, most are runtime checks that requires you to cross that code in order to be detected. In large projects this can lead to the introduction of subtle bugs that are not detected until much later.
A solution to this is a static analyzer. This project can grow quite big but also can start with a small feature-set and grow from the foundation laid on. It is not a tool to be used so often, which makes performance not a primary concern. The tool would scrape scripts, scenes, and resources, looking for references that are not there (such as
get_node() call without the node in the tree), considering all of them put together instead of in isolation.
There are a number of errors this could catch that are not normally detected by the editor, such as reference to missing node, calling a non-existent function, wrong number of arguments in a function connected to a signal, etc.
Related issues and pull requests: #19811.
"Animation Bootcamp" in Godot
Skills: C++, 3D
https://www.youtube.com/watch?v=LNidsMesxSE Original Video: https://www.gdcvault.com/play/1020583/Animation-Bootcamp-An-Indie-Approach (Requires Flash)
Should be doable as a generic/parametric character module.
Reimplement Godot's theme editor
Skills: C++, (potentially) GDScript
Godot's theming system is very simple—it is still a game engine ;)—Styleboxes are assigned to different states of Control-Nodes. There is no cascading and no shared variables. This makes it very easy to understand, and results in very little complexity. But also comes with a cost. Setting up themes is super tedious. For example, a color change requires you to update hundreds of values.
The goal of this project is to design a theme editor, which will generate a theme with systems, like a color palette, so that we get the best of both worlds. The simplicity of Godot's theming and an advanced theming structure when setting up a theme using the theme editor. There is a big amount of freedom and space for creative ideas to make creating themes a pleasure, while still keeping the core architecture as simple as possible.
Another related task is to improve some aspects of the editor theme, such as caching icons for faster startup time, color icons with modulation (looks better on light theme, no re-render of icons when changing from dark to light), and more.
Multiplayer Scene Editor
Skills: Networking, C++
An editor plugin that allows multiple people to edit the same scene, using the remote scene edition protocol we have for running games. Possible features or issues:
- A central server that provides authority for the edition protocol, maybe simlpy by forwarding messages in an arbitrary order.
- Integration with VCS (such as Git, SVN, Mercurial, etc.)
- Resolution of conflict when a new resource is added that requires new files (i.e. someone adds a texture that other people don't have. Maybe only allow new references to files that already exist in the VCS for simplicty, or provide warnings/placeholders when a client doesn't have the file).