After a bit more than one year of work, the Godot developers and contributors are delighted to get their new release out the door, Godot 3.1! It brings much-requested improvements to usability and many important features.

Godot 3.0 was a massive release, which required large rewrites of the engine codebase and breaking backwards compatibility significantly. This new version builds upon it by improving it and finishing the pending work.

As a result, Godot 3.1 feels more mature and easy to use, and it does away with many hurdles introduced in the previous versions.

Download Godot 3.1 now and keep on reading about the great features added in this version.


As always, please remember that we are 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. 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.


While this article focuses mostly on the new features of the engine, it’s worth mentioning that Godot’s documentation has seen a lot of work from dozens of contributors. A detailed changelog is being worked on, you can see the current draft on GitHub.

New features

Release trailer by Nathan Lovato (GDquest) showcasing the outstanding new features of Godot 3.1.

Here’s an index of the outstanding features described in this post:

OpenGL ES 2.0 renderer


The Godot 2.x branch used OpenGL ES 2.0 / OpenGL 2.1 (GLES2) as its rendering API. This worked well, but had many limitations preventing us to use more modern rendering techniques.

In Godot 3.0, all rendering code was rewritten to use the more modern OpenGL ES 3.0 / OpenGL 3.3 specifications (GLES3) and the OpenGL ES 2.0 renderer was removed. This seemed like a great idea at the beginning, but ended up giving us many problems, such as:

  • Bad performance on old mobile/desktop hardware which wasn’t designed for the more modern rendering techniques being used.
  • Incompatibility with older mobile devices which do not support OpenGL ES 3.0.
  • Incompatibilities in the HTML5 platform, as not all browsers support WebGL 2.0 (the equivalent specification for OpenGL ES 3.0).
  • Lots and lots of driver bugs in mobile and desktop. On desktop, it seems that modern OpenGL is not well supported by various driver vendors, and regressions keep coming up in new drivers on macOS and Windows. On mobile, as OpenGL ES 3.0 is comparatively new, there is a range of many years where devices with very buggy drivers came out. Even modern flagship devices still ship with crippling driver bugs.

Due to this, we were forced to bring back the OpenGL ES 2.0 / OpenGL 2.1 renderer. This work was done by karroffel and I (reduz).

On the 2D side, this new renderer is feature complete. On the 3D side, a simpler approach to rendering was done that is intended to be more limited, but more compatible. It has the following features and limitations:

  • Rendering is done entirely on sRGB color space (the GLES3 renderer uses linear color space). This is much more efficient and compatible, but it means that HDR will not be supported. Lighting looks a bit different too.
  • Some advanced PBR features are not supported, such as subsurface scattering. Unsupported features will not be visible when editing materials.
  • Some shader features will not work and throw an error when used (which is to be expected when using an older OpenGL version).
  • Some post processing effects are not present either. Unsupported features will not be visible when editing environments.
  • As this back-end is intended to run on the lowest end hardware possible, shaders need to be kept very small. As such all lighting is done by using a forward multi-pass approach.
  • GIProbes of course don’t work. Use baked lightmaps instead.
  • GPU-based Particles will not work as there is no transform feedback support. Use the new CPUParticles node instead (more on this later).

From the points above, it must be clear that OpenGL ES 2.0 is not a fallback but a different platform you should target your game for. It looks different and has different limitations. If your game aims for absolute maximum compatibility, use this backend instead of the GLES3 one. If you aim for modern features at the cost of compatibility, don’t use it.

Optional typing in GDScript


This has been one of the most requested Godot features from day one. GDScript allows to write code in a quick way within a controlled environment. As any dynamically typed language, it allows churning out large amount of code at a high speed.

However, dynamically typed languages have some limitations that can be a hassle:

  • Code completion is not always possible.
  • Performance is constrained to the interpreter.
  • Does not always catch errors during compile (or write) time.
  • Code can be less readable and difficult to refactor.

Our contributor George Marques (vnen) did a fantastic job implementing optional typing in GDScript to tackle these problems. For Godot 3.1, optional typing is a parser-only feature. The plan is, afterwards, to include typed instructions in the state machine to greatly optimize performance.

One nice implementation detail is that the code editor will now show which lines are safe with a slight highlight of the line number. This will be vital in the future to optimize small pieces of code which may require more performance.

This work also enabled GDScript warnings, which will now be raised by the parser. You can toggle which warnings you want to see in the Project Settings.

Revamped inspector


The Godot inspector has been rewritten from scratch. It is now a lot more comfortable to use. Among some of the nice new features are proper vector field editing, sub-inspectors for resource editing (no longer needed to switch to a separate one when editing resources), better custom visual editors for many types of objects, very comfortable to use spin-slider controls, better array and dictionary editing and many many more features.

Revamped 2D editor


The Godot 2D editor has seen a serious rewrite by Gilles Roudiere (Groud). There is a much better use of gizmos, as well as showing small crosses where generic nodes exist. In particular, it solves a major pain point for new Godot users by no longer offering scaling handles for collision shapes, but letting you directly change their size instead.

New TileSet editor

tileset editor.jpg

The tileset creation workflow in Godot had always been a major pain point for users due to its tediousness. Mariano Suligoy (MarianoGnu) wrote a whole new TileSet editor with many features familiar from other tileset creation software, and a much better support for the autotile feature added in 3.0.

Revamped filesystem dock


Another fine piece of work by contributor Gilles Roudiere (Groud) and sponsored by Gamblify. The new filesystem dock has been rewritten and now supports a single tree + files view by default, with thumbnails for the files. It makes it easy to navigate projects and understand where everything is.

KinematicBody2D (and 3D) improvements


Kinematic bodies are among Godot’s most useful nodes. They allow creating very game-like character motion with little effort. For Godot 3.1 they have been considerably improved:

  • Support for snapping the body to the floor.
  • Support for RayCast shapes in kinematic bodies.
  • Support for synchronizing kinematic movement to physics, avoiding a one-frame delay.

Revamped animation editor


The animation editor has also been completely rewritten to ensure a much better experience. Some of the more outstanding features are:

  • Friendlier layout, with less clutter.
  • Key previews for most types of keys allow seeing the key values within the track.
  • Ability to group tracks by node.
  • Key editing in inspector.
  • Copying and pasting tracks.
  • Capture tracks, which interpolate from existing values.
  • Ability to create custom track editor plugins.
  • New track type: Bezier.
  • New track type: Animation (play animations of sub-animation player, allowing complex cinematics).
  • New track type: Audio (play audio on StreamPlayers, including 2D and 3D).

Revamped AnimationTree


The old AnimationTreePlayer has been deprecated in favor of the new AnimationTree node. Besides improving the blend tree, it also supports blend spaces (1D and 2D), a state machine, and a modular approach that allows you to combine all modes hierarchially to better reflect your gameplay.

Support for root motion as well as the ability to write your own custom blend nodes has also been added.

New axis handling system

After several months of deliberation and prototypes, we settled on a really good approach to axis mapping, courtesy of Gilles Roudiere (Groud). Instead of going the way other game engines do it with axis definitions, Godot 3.1 uses the novel concept of “action strength”.

While it may take a bit of time to sink in, this approach allows using actions for all use cases and it makes it very easy to create in-game customizable mappings and customization screens.

Visual shader editor


The visual shader editor has made a comeback. This was a pending feature to re-implement in Godot 3.0, but it couldn’t be done in time back then. The new version has a lot of niceties, such as PBR outputs, port previews, and easier to use mapping to inputs.

2D skeletons


It is now possible to create 2D skeletons with the new Skeleton2D and Bone2D nodes. Additionally Polygon2D vertices can be assigned bones and weight painted. Adding internal vertices for better deformation is also supported.

2D meshes


Godot now supports 2D meshes, which can be used from code or converted from sprites to avoid drawing large transparent areas.

Improved 3D editor


Just like the 2D editor, the 3D editor has also been considerably improved. Joan Fons Sanchez (JFons) did a magnificent job by improving how selection works and entirely rewriting the gizmo system.

3D softbody support


Andrea Catania (Odino), who integrated Bullet to Godot 3.0, has added support for soft bodies in Godot 3.1. This is a very easy to use implementation supporting many nice features.

Ragdolls and Skeleton IK


Also by Andrea Catania (Odino), there is a new PhysicalBone node used for easy ragdoll setups, as well as a SkeletonIK system which allows creating simple Inverse Kinematics (IK) chains for existing skeletons and toggling bones from regular to IK mode.

Constructive Solid Geometry (CSG)


CSG tools have been added for fast level prototyping, allowing generic primitives and custom meshes to be combined via boolean operations to generate more complex shapes. They can also become colliders to test together with physics.

OpenSimplex and NoiseTexture


Support has been added for OpenSimplex (another very requested feature from users) by Joan Fons Sanchez (JFonS). Additionally, a noise texture can now be used as a resource, which generates noise on the fly.

CPU-based particle system

Godot 3.0 integrated a GPU-based particle system, which allows emitting millions of particles at little performance cost. As OpenGL ES 2.0 support was added, this feature could not be supported there, so we added alternative CPUParticles and CPUParticles2D nodes.

These nodes do particle processing using the CPU (and draw using the MultiMesh API). They are quite efficient for lesser amounts of particles and work on all hardware. Additionally, these nodes open the window for adding features such as physics interaction, sub-emitters or manual emission… which are not possible using the GPU.

Greatly improved C# support

Ignacio Etcheverry (neikeq) and other contributors have done a tremendous work since Godot 3.0 to improve the C# integration in Godot. As of 3.1, C# projects can be exported to Linux, macOS and Windows. Support for Android, iOS and HTML5 will come further down the road, with Android being the current priority.

Both Ignacio and HP van Braam (hpvb) did great work to improve our Mono builds and remove some of its previous hurdles, such as being tied to a specific Mono version. The relevant bits from the Mono SDK are now included directly with the editor binary, and you only need to install MSBuild to build and ship C# games.

Networking improvements

Fabio Alessandrelli (Fales) did a number of improvements to Godot’s low-level networking APIs and high-level multiplayer API. He also implemented support for WebSockets, and Max Hilbrunner (mhilbrunner) helped him with various fixes and adding support for UPnP.

Custom classes registration

Will Nations (willnationsdev) implemented a way to register GDScript classes (and thus scenes/nodes) as custom classes that can be added directly from the “Add Node” dialog as if they were built-in nodes. This is done with the class_name keyword, which also allows defining a custom icon for the node.

MIDI and microphone input

Marcelo Fernandez (marcelofg55) added support for using MIDI devices as input devices. Together with SaracenOne, they also added support for capture microphone audio.

More VCS friendliness

Godot is already unrivalled with regards to being friendly to version control systems (VCS). The new 3.1 version includes some very requested enhancements such as:

  • Folded properties are no longer saved in scenes, avoiding unnecesary history pollution.
  • Non-modified properties are no longer saved. This worked up to some extent before with properties that were not zero but it now applies universally. This reduces text files considerably and makes history even more readable.

Many more changes

The above are only the most outstanding features. Hundreds of other changes have been made since Godot 3.0. You can read about them in the release changelog.

A heartfelt Thank You to all the contributors who worked on Godot 3.1!

Compatibility with 3.0

Godot 3.1 strives to maintain compatibility with Godot 3.0.x, so your projects should be easy to port over to the new version. There have been some compatibility changes though, especially in GDScript due to the new optional typing changes, but they should be easy to adapt to in a couple of hours at most. Refer to the changelog for details on what changed exactly.


After so much work on improving usability and compatibility, the main focus will move into further improving rendering. The current GLES3 renderer will be deprecated in favor of a Vulkan-based one and 3D rendering will once again become the priority. The goal is to release Godot 4.0 one year from now (or less, I hope) with a top notch modern renderer capable of everything the other big engines can do.

In parallel, other contributors will continue working on other areas and usability will keep improving. We plan to release Godot 3.2 in the second half of 2019 with those improvements (the Vulkan work towards Godot 4.0 will be done in a separate feature branch). Some of the areas we want to focus on are:

  • Adding typed instructions to GDScript to improve performance of typed code.
  • Adding FBX support, either via Assimp or OpenFBX (the official Autodesk library cannot be used due to their restrictive licensing terms).
  • Improve the Android and iOS export workflow, in particular adding a simpler way to integrate mobile SDKs such as AdMob, without having to recompile the whole engine.
  • Getting the Godot editor to run on a web browser (ideal for public teaching institutions).
  • Improving networking to better support dedicated servers and modern protocols.

And many, many more features. Of course, always keeping priority on stability and usability.

Finally, we will also have patch releases for Godot 3.1.x to fix some more bugs and improve usability in a backward compatible way. In particular, some of the new features in 3.1 might still have issues preventing their use in some scenarios. We know for example of yet-unresolved OpenGL ES 2.0 issues on some lower end mobile devices, which will be addressed soon in 3.1.x maintenance releases.

Help us reach our next funding goal and speed up Godot development!

We are looking to get enough funding to hire a dedicated generalist. This will significantly reduce the time between adding features and new releases, which is currently our biggest bottleneck. Having a dedicated generalist will help us work constantly on fixing issues and improving usability even while new features are being added, reducing the time required to wrap up a new release.

Again, 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 that you support our cause, then please consider becoming our sponsor.

And now, have fun with Godot 3.1’s new features!