Godot contributors are thrilled and delighted to release our newest major update, Godot 3.2! It’s the result of over 10 months of work by close to 450 contributors (300 of them contributing to Godot for the first time) who authored more than 6000 commits!
Godot 3.2 is a major improvement over our previous 3.1 installment, bringing dozens of major features and hundreds of bugfixes and enhancements to bring our game developers an ever-improving feature set with a strong focus on usability.
Download Godot 3.2 now and read on to learn more about its history, our support plans and the many new features in this update.
Small release grown big
Godot 3.2 was initially planned to have a short release cycle (4 to 6 months), with few new features and mostly fixes for some of the main issues of our previous main release, Godot 3.1 (March 2019). And indeed, shortly after releasing 3.1 and having written a handful of new features intended for 3.2, our lead developer Juan Linietsky moved on to developing the upcoming Vulkan renderer for Godot 4.0 in a separate branch.
But the rest of us engine contributors did not stay idle in the meantime, and a strong focus was put on fixing as many issues as we could to make Godot 3.2 a long-lasting release. Many new features introduced in Godot 3.0 (January 2018) and 3.1 still needed refinement, and thus a lot of work was poured into those areas to improve the usability, implement missing components and fix bugs reported by our growing userbase.
While the development branch was feature frozen (i.e. no big new features accepted) as early as the end of August 2019, it took several months of work to polish the new features and fix many of the long standing bugs which kept being postponed from release to release. For Godot 3.2, our contributors dug deep into the depths of the issue tracker and solved close to 2000 issues reported over the years, as early as in 2015!
And thus, without notice, the “small” 3.2 release organically grew into something nearly as big as its 3.1 predecessor, pushing the release ETA to sometime in November 2019, and after factoring in the usual delay of 2-3 months past our best guesstimate, here we are!
As a matter of fact, today’s release marks the second anniversary of Godot 3.0, which was released on January 29th, 2018. It’s an unexpected but nice way to kickstart the development journey towards our next major achievement, Godot 4.0!
We hope that you will all enjoy the 3.2 version as much as we enjoyed developing it!
Almost every area of the engine has seen some degree of enhancement, and we encourage users to move their active projects to Godot 3.2 if they can. We did our best to preserve compatibility between 3.1 and 3.2 projects, but a low amount of compatibility breaking changes have still been done and might require light porting work for big projects (see the Changed section in the Changelog for details).
For users who choose to stay on the 3.1 branch, we will keep maintaining it with relevant bug fixes and platform-specific changes in the coming months (notably with a 3.1.3 maintenance release). However, the main update focus will be on the 3.2 branch.
The way ahead
Before trying to give an overview of the most prominent new features in Godot 3.2, let’s answer a question that many of you may have: what kind of support can you expect for the 3.2 branch, and what will be the next milestones?
As some of you may know, our next major milestone is Godot 4.0, which will bring a new Vulkan-based rendering backend in lieu of the current OpenGL ES 3.0 / OpenGL 3.3 backend. The lower end OpenGL ES 2.0 / OpenGL 2.1 backend will be kept and ported over to the new architecture for Godot 4.0. The curious among you may read Juan’s progress reports for details on this new architecture and rendering features implemented for 4.0 (reports 1, 2, 3, 4, 5, and 6).
The new rendering architecture will be completely rewritten to modernize the current 10-year-old design and fit the latest graphics APIs, but will involve a significant compatibility breakage with 3.x projects. We have many other areas where compatibility-breaking changes have been queued for years in expectation of the next major release, which will be done in 4.0 too.
For this reason, upgrading projects from Godot 3.2 over to Godot 4.0 will require significant work. For those who experienced the transition from Godot 2.1 to 3.0, be reassured, the scope of the changes won’t be near as bad as it was back then. We will do our best to fully document the relevant changes and provide tools to automate everything that can be automated, but we still expect many users will choose to stay on the Godot 3.2 branch if they are happy enough with its feature set.
For that reason, we will provide long-term support for the 3.2 branch, like we have done for Godot 2.1 from 2016 to 2019 (and still do on an “as needed” basis). There will be regular maintenance releases (3.2.x) bringing important bug fixes, usability enhancements, and some new features.
Many of the features which have been contributed over the past 6 months could not be merged in Godot 3.1 to keep its scope manageable, but they will be reviewed, merged and potentially cherry-picked for 3.2.x maintenance releases if they do not impact the stability and compatibility of the 3.2 branch. To give a few examples, features such as AOT compilation and iOS support for C# projects, ARCore support, or DTLS support, will likely be integrated in future 3.2.x maintenance releases, once they are ready.
Supporting the project
Godot is a not-for-profit organization dedicated to providing the world with the best possible free and open source game technology. Donations have played a vital role in enabling us to develop Godot at this sustained pace, recently enabling us to hire George as full-time generalist. Thanks to all of you patrons from the bottom of our hearts!
If you use and enjoy Godot, plan to use it, or want support the cause of having a mature, high quality free and open source game engine, then please consider becoming our patron. If you represent a company and want to let our vast community know that you support our cause, then please consider becoming our sponsor. Additional funding will enable us to hire more core developers to work full-time on the engine, and thus further improve its development pace and stability.
Now on to the good stuff: what’s new in Godot 3.2?
There have been thousands of changes, big and small, so listing everything would be impossible. You can however consult the detailed Changelog, where we attempted to list most relevant changes, separated by category: additions, changes, removals, and fixes.
In the rest of this post, we aim to give a broad overview of the most noteworthy features and changes in Godot 3.2. You can read in order, or use the index below to jump to your areas of interest. The engine areas are listed in no particular order.
- Documentation: More content, better theme
- Mono/C#: Android and WebAssembly support
- AR/VR: Oculus Quest and ARKit support
- Visual Shaders overhaul
- Graphics/Rendering improvements
- 3D asset pipeline: glTF 2.0 and FBX
- Networking: WebRTC and WebSocket
- Android build and plugin systems
- New editor features
- Coding tools
- 2D: Pseudo 3D, Texture atlas, AStar2D
- GUI: Anchor/margins workflow, RichTextLabel effects
- Audio generators and spectrum analyzer
- Improved convex decomposition
Documentation: More content, better theme
stable documentation branch has been updated to the 3.2 version. The same content is also available as the
3.2 branch. The previous stable version can now be found in the
We recommend that new users start with our official Step by Step tutorial to learn the basic concepts of Godot.
Both the Class Reference and the tutorials gained a lot of new content during the development of Godot 3.2. While some of it is specific to new features, the majority is applicable to pre-existing content which lacked exhaustive documentation until now.
Since Godot 3.1, the Class Reference went from 73% complete to 90% complete today! Over 2500 new descriptions have been written for nodes, methods, properties, constants or signals, and most of the 7000 pre-existing descriptions have been proofread and improved. The quality increase is huge, and owed to the 200 contributors who worked on the documentation this release cycle!
Both the built-in docs and the online version got a nice formatting improvement, especially visible with the new themes (light and dark, auto-detected from system settings) for the Web version designed by Hugo Locurcio.
For the first time, Godot’s documentation is also available in several languages! Only the
latest branch is translated, but it currently matches the content of the
stable branch. We have instances in Chinese (Simplified), French, Japanese, Spanish, Korean, Polish, Russian, Portuguese (Brazil) and many more - some are more complete than others (part of the content might still be in English), but you can also help with the translation effort!
Mono/C#: Android and WebAssembly support
C# support was initially implemented in Godot 3.0 using Mono, with support for running projects in the editor. Godot 3.1 added support for exporting projects to desktop platforms (Linux, macOS and Windows).
For Godot 3.2, our C# maintainer Ignacio Etcheverry (neikeq) has been quite busy, first implementing support for Android, and later for WebAssembly. Initial support for AOT compilation was also merged, but it is not enabled yet in Godot 3.2 as additional testing and packaging changes are necessary. AOT will enable better performance for the WebAssembly port (currently using the interpreter) and is also a prerequisite for the upcoming iOS platform support, which should be included in a later 3.2.x release.
C# version of the Dodge the Creeps demo running in Firefox.
Other noteworthy improvements are the support for MonoDevelop/Visual Studio for Mac as well as Jetbrains Rider as external editors, C# 8.0 support via Mono 6.6, the switch to .NET Framework 4.7 as default target, and the rewrite of the Mono-specific editor code in C# (ported from C++). Additionally, dozens of bugs have been fixed, making the C# experience in Godot much more mature.
We’re thankful to Microsoft for funding Ignacio’s work on C# support.
AR/VR: Oculus Quest and ARKit support
Our prolific AR and VR maintainer Bastiaan Olij has been able to finalize and merge a lot of long-running development efforts for Godot 3.2.
His first work on ARKit support for iOS dates back to 2017, and it took a couple years of iterations to come to the right design that would fit well in Godot’s architecture, especially with regards to the underlying CameraServer API. On the Android front, ARCore integration is yet unmerged, but is already functional. Once distribution hurdles are solved, we should be able to include it in a future 3.2.x release.
2019 was the big year for Godot’s VR support, with both Oculus and Valve reaching out to us to support our effort with hardware and technical contacts. Bastiaan released the Oculus mobile VR plugin, and quickly got help from experienced Oculus Quest users to co-maintain the plugin and improve the overall integration (especially Fredia Huya-Kouadio and Holger Dammertz). There is a burgeoning community of Quest VR developers already publishing interesting Godot-based prototypes, and the stable 3.2 release should boost it. Stay tuned for updates as Bastiaan will soon upload pre-compiled VR plugins for all supported headsets to our Asset Library, and likely post an update on this blog when he does, with instructions on how to get started.
Holger Dammertz’s Voxel Works Quest prototype made with Godot for Oculus Quest.
Visual Shaders overhaul
Godot 3.1 introduced a new graph-based editor to edit shaders visually, reimplemented from the previous version that was included in Godot 2.1.
For Godot 3.2, our contributor Yuri Roubinsky did a huge rework of the new visual shader’s UX, and eventually assumed full maintainership of the feature. Beyond improving usability and fixing bugs, he implemented many additional useful nodes to write more advanced shaders with greater flexibility.
Read his progress reports (part 1 and part 2) for details on all the new features.
Yuri did not stop there, as he also implemented many additional features for the classical script shaders, such as support for constants, arrays and varyings. Many shader builtins specific to the GLES 3 backend have been ported over to GLES 2, while a number of features which cannot be implemented in GLES 2 due to restrictions on the GLSL support have been identified as such and will properly raise compilation errors.
With the shift towards Vulkan for 4.0, we made the difficult decision to put rendering features on hold for Godot 3.2. As mentioned, our lead developer Juan has spent the time since the release of 3.1 working on the new Vulkan renderer for 4.0, and accordingly, few changes have been made to Godot’s renderer for version 3.2.
Still, other contributors were there to pick up the torch, and notably Clay John has been working magic on both the GLES2 and GLES3 rendering backends.
Among the changes included in Godot are changes to the PBR pipeline to match other real-time PBR engines like Blender’s Eevee and Substance Designer. You can expect scenes that make heavy use of a PBR workflow to look closer to how they do in your 3D modeling software.
Many GLES3 features have been ported to GLES2 including [**support for MSAA**](https://github.com/godotengine/godot/pull/28518), and various post-processing effects (glow, DOF blur, and BCS).
Many default render settings have been tweaked and optimized to result in both better image quality and better performance by default. As always, settings can be tweaked to suit the project (e.g. SSAO performance and quality settings).
Many bugs have been fixed, especially to the GLES2 renderer resulting in an even more stable experience.
3D asset pipeline: glTF 2.0 and FBX
Thanks to the dedicated work of several contributors (Ernest Lee, Gordon MacPherson and Marios Staikopoulos), Godot now has a fully functional glTF 2.0 import pipeline, as well as initial support for the FBX format. A significant portion of this work was generously donated by IMVU.
glTF 2.0 is considered to be the ideal choice for importing 3D scenes into Godot, and is seeing increasing industry adoption as a standard. In particular, the import of glTF 2.0 animations was greatly improved. Through collaboration with the Blender community, significant improvements in glTF 2.0’s import and export pipelines were made, which will be included in the upcoming Blender 2.83 release.
Godot now supports skeleton skins when importing glTF 2.0 and FBX scenes. Skin support allows multiple meshes to share a single skeleton.
The ESCN and Collada pipeline haven’t been updated significantly and act as they did in Godot 3.1. Skin support was not added yet to ESCN or Collada.
We also have included basic FBX support (currently in a preview state). FBX files exported from Blender with animations are partially supported. We do not support Maya or 3ds Max FBX files. In a future update we will improve compatibility for other packages.
Although the FBX and glTF 2.0 formats permit more than 4 bone weights per vertex, such meshes are currently unsupported in Godot 3.2. See also FBX2glTF as an option to convert pre-existing FBX content to glTF 2.0.
Should you have any issues with any assets being imported, please file a bug report with a reproduction model.
Networking: WebRTC and WebSocket
Thanks to a generous award by Mozilla, our networking maintainer Fabio Alessandrelli has been able to work continuously on networking improvements during the Godot 3.2 release cycle.
The first part of his work covered implementing WebRTC support, which is detailed in his progress reports (1, 2, and 3).
Other networking changes involve the support for UDP multicast, WebSocket demos and tutorials, a WebSocket SSL server and basic cryptographic features.
On the debugging front, our contributor Joan Fons Sanchez added a new network profiler, which will help you monitor the bandwidth usage of your game in real time. You will see the amount of uploaded and downloaded data per second, as well as an RPC counter. The counter view can be very useful when trying to optimize your networking communications, since you will be able to identify which nodes in your game are doing the biggest amount of networked function calls.
While keeping the maintainership of our networking features, Fabio will now move on to another Mozilla-funded work package to improve the WebAssembly/HTML5 port and bring the Godot editor to the Web! He already started with a much needed enhancement included in this release, which is the addition of a local HTTP server used by the editor to run WebAssembly exports.
Android build and plugin systems
Before moving onto Vulkan development, Juan had time to implement a long-awaited refactoring of the Android plugin and export systems.
Many users want to be able to build their own Android templates with custom Java modules adding support for third-party social features, monetization platforms, etc. The previous workflow forced them to build their own Godot APK from source using custom modules, which can be tedious.
Now, Godot includes two separate export systems: the usual one with a prebuilt APK, and the new “Custom Android build” workflow, which lets users install the pre-compiled Godot source template and do their own modifications before generating a new APK.
A new plugin system is also included to make better use of this custom build workflow, allowing users to configure the custom build via plugins instead of doing local modifications to the Godot source template (which might need to be erased on update). Existing plugins will need to be ported over to the new system, but this should be fairly easy.
The Android port also got a massive refactoring by a new contributor, Fredia Huya-Kouadio, who quickly became one of our main Android maintainers. This enabled us to modernize the code, fix some long-standing issues and improve upon the initial work done by Juan.
New editor features
Godot’s editor is the main interface for the engine, and thus it got a ton of attention from all contributors. The following are just a handful of noteworthy changes.
It is now possible to disable editor features. This allows to hide features that you don’t intend to use to simplify the interface. This can be useful for tutors or companies who might want to restrict the access to some areas of the editor to let their students/teams focus on a specific subset.
Initial integration for VCS support has been merged, and there is a Git plugin which can be used to enable basic Git support in the editor. This is the result of Twarit Waikar’s work for GSoC 2019.
Erik Selecký implemented a feature to override the camera of the running game with that of the editor viewport. That means that you can explore your running game using the editor features (freelook, inspection of nodes, etc.).
And many other things!
Our contributor Geequlim with help from the GSoC 2019 student Ankit Priyarup implemented a Language Server Protocol for GDScript, which is used to provide code completion, documentation and other tools to external editors. As of now, there are client plugins for VS Code plugin and Atom.
There were also many improvements to the built-in GDScript editor:
- Thanks to Paul Batty, the script editor now features a minimap view, which was a long-requested feature. He also added an icon next to signal callbacks to show that they are connected to signals.
- Tomasz Chabora added support for setting bookmarks in scripts to keep references to specific lines, as well as a feature to evaluate and reduce a mathematical expression under the cursor.
- While working on LSP features, Geequlim also took the time to improve the code completion feature of the built-in editor, notably showing different icons based on the type of code completion option (classes, methods, properties, constants, etc.).
Finally, there were many VisualScript improvements) from another GSoC 2019 student, Swarnim Arun, which should greatly improve usability.
2D: Pseudo 3D, Texture atlas, AStar2D
Juan implemented a “pseudo 3D” feature which enables an easy way to add depth to 2D games by using several canvas layers, making them follow the main viewport and scale automatically to fake perspective.
Support for texture atlases also comes back to Godot with 3.2, with an easy way to generate deterministic atlases directly from the editor.
Along with various performance optimizations for Godot’s AStar implementation, an AStar2D variant was implemented to simplify its use for 2D pathfinding.
GUI: Anchor/margins workflow, RichTextLabel effects
After having done a lot of work on the usability of GUI Controls in Godot 3.0, Gilles Roudiere did another pass at improving UX based on user feedback, with a pull request improving the anchors and margin workflow.
An unexpected but very cool feature was implemented by Eoin O’Neill to add real-time text effects to RichTextLabel, as well as the possibility to define your own custom effects and BBCode tags.
Audio generators and spectrum analyzer
To add to the 3.2 feature set before diving into Vulkan, Juan implemented audio stream generators which let you easily generate sound waves by pushing individual frames or a buffer, and a spectrum analyzer.
Improved convex decomposition
Using the V-HACD library, Godot can now decompose concave meshes into precise and simplified convex parts.
This greatly simplifies the process of generating e.g. collision shapes to add collisions to any given 3D mesh.
Many more features
We would like to take the opportunity to thank all of our amazing contributors for all the other great features merged since 3.1, and the hundreds of bugfixes and usability improvements done over 2019. Even if not listed here, every contribution makes Godot better, and this release is truly the work of hundreds of individuals working together towards a common goal and passion.
For more details on other changes in Godot 3.2, please consult our curated Changelog, as well as the raw changelog from Git (chronological, or sorted by authors).
As a community effort, Godot relies on individual contributors to improve. In addition to becoming a Patron, please consider giving back by: writing high-quality bug reports, contributing to the code base, writing documentation, writing tutorials (for the docs or on your own space), and supporting others on the various community platforms by answering questions and providing helpful tips.
Last but not least, making games with Godot and crediting the engine goes a long way to help raise its popularity, and thus the number of active contributors who make it better on a daily basis. Remember, we are all in this together and Godot requires community support in every area in order to thrive.
Now go and have fun with 3.2!