Godot Engine Official

Dev snapshot: Godot 4.6 beta 2

2025-12-19T12:00:00+00:00

As 2025 winds to a close, so too does our team for the holiday season. Before we head off, let us leave you with a parting gift: the final development build of the year, 4.6 beta 2!

We’ve already discovered and tackled a fair number of regressions since 4.6 beta 1, which we’re hoping will lend itself to a quick release cycle. However, there’s still further bugfixing and testing to be done, so users are encouraged to report whatever new issues crop up this release.

Please consider supporting the project financially, if you are able. Godot is maintained by the efforts of volunteers and a small team of paid contributors. Your donations go towards sponsoring their work and ensuring they can dedicate their undivided attention to the needs of the project.

Jump to the Downloads section, and give it a spin right now, or continue reading to learn more about improvements in this release. You can also try the Web editor, the XR editor, or the Android editor for this release. If you are interested in the latter, please request to join our testing group to get access to pre-release builds.

The cover illustration is from Nine-Ball Roulette, a thriller where you and up to 3 friends take part in a relaxing game of pool with a little Russian Roulette on the side. You can buy the game on Steam, and check out the developers on YouTube!

Highlights

For an overview of what’s new overall in Godot 4.6, have a look at the highlights for 4.6 beta 1, which cover a lot of the changes. This blog post only covers the changes between beta 1 and beta 2. This section covers the most relevant changes made since the beta 1 snapshot, which are largely regression fixes:

Editor: Disable tool button for multiple nodes (GH-113944).
Editor: Fix shader editor minimum size (GH-113916).
Editor: Show file when FileSystem is searched with UID (GH-102789).
GUI: Fix TextEdit does not auto scroll properly on certain vertical sizes (GH-113390).
Platforms: iOS: Automatically enable iphone-ipad-minimum-performance-a12 if project is using Forward+/Mobile renderer (GH-114098).
Platforms: Linux: X11: Fix input delay regression (GH-113537).
Rendering: Update Mesa NIR to 25.3.1 + Make each SPIR-V -> DXIL conversion thread allocate from its own heap (GH-113618).
Rendering: OpenGL: Split the ubos for motion vectors into separate uniforms to fix Adreno GPU crash (GH-114175),
Thirdparty: Replace minimp3 with dr_mp3 (GH-96547).
Thirdparty: SDL: Update to 3.2.28 (GH-113968).
Translations: Sync with latest Weblate, new 4.6 strings are now available to translate.

Changelog

64 contributors submitted 198 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-beta1. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit 551ce8d47.

Downloads

Download Godot 4.6 beta2

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

While engine maintainers try their best to ensure that each preview snapshot and release candidate is stable, this is by definition a pre-release piece of software. Be sure to make frequent backups, or use a version control system such as Git, to preserve your projects in case of corruption or data loss.

Known issues

During the beta stage, we focus on solving both regressions (i.e. something that worked in a previous release is now broken) and significant new bugs introduced by new features. You can have a look at our current list of regressions and significant issues which we aim to address before releasing 4.6. This list is dynamic and will be updated if we discover new showstopping issues after more users start testing the beta snapshots.

With every release, we accept that there are going to be various issues which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

XR: Motion vectors are currently broken in the compatibility renderer, causing geometry to predominantly render as black (GH-107438).

Bug reports

As a tester, we encourage you to open bug reports if you experience issues with this release. Please check the existing issues on GitHub first, using the search function with relevant keywords, to ensure that the bug you experience is not already known.

In particular, any change that would cause a regression in your projects is very important to report (e.g. if something that worked fine in previous 4.x releases, but no longer works in this snapshot).

Support

Godot is a non-profit, open-source game engine developed by hundreds of contributors in their free time, as well as a handful of part and full-time developers hired thanks to generous donations from the Godot community. A big thank you to everyone who has contributed their time or their financial support to the project!

If you’d like to support the project financially and help us secure our future hires, you can do so using the Godot Development Fund platform managed by Godot Foundation. There are also several alternative ways to donate which you may find more suitable.

Donate now

Inverse Kinematics Returns to Godot 4.6

2025-12-16T10:00:00+00:00

In Godot 4.6, IK is back in 3D!

Of course, “IK” means inverse kinematics.

If you have experience with Godot 3.x, you might remember that IK was removed during the upgrade to 4.0. I explained in a previous blog post that it was removed because the old skeleton API design had issues and needed reworking.

Then, you might wonder if it was theoretically possible to implement IK alongside the SkeletonModifier3D implementation in 4.4. However, we had to avoid adding immature features and then hastily removing it again. To implement IK, we staged the elements for the entire IK across three versions.

This blog post will explain that journey.

Godot 4.4

In Godot 4.4, I implemented the base class for SkeletonModifier3D, along with two new modifiers, LookAtModifier3D and RetargetModifier3D.

SkeletonModifier3D / LookAtModifier3D

LookAtModifier3D was the minimal implementation to verify that the SkeletonModifier3D design was correct. LookAtModifier3D could be considered equivalent to one-bone IK, so it was suitable as a test case.

RetargetModifier3D

However, when implementing LookAtModifier3D, I confirmed that users must specify the bone axis based on the bone rest. It was my initial concern that the retarget feature implemented in 4.0 discarded the bone rests of the imported skeleton.

As this concern became a certainty, I attempted to preserve bone rests by implementing RetargetModifier3D.

It was fortunate for me that the processing order design of SkeletonModifier3D matched the requirements for implementing RetargetModifier3D.

Godot 4.5

In Godot 4.5, I implemented SpringBoneSimulator3D and BoneConstraint3D (and its three child classes AimModifier3D, ConvertTransformModifier3D and CopyTransformModifier3D).

By the way, I’m involved in a project that utilizes a 3D character model format known as VRM. VRM has implementations of SpringBone and Constraint as model-specific configurations that can be ported to cross-platform environments, so ensuring compatibility with these was one of the purposes.

SpringBoneSimulator3D

One challenging part of implementing SpringBoneSimulator3D was creating the bone chain internally. Specifically, by setting the root bone as the ancestor and the end bone as the descendant, we could retrieve the bones between them and automatically construct the joint array.

Compared to users manually creating these arrays, this approach reduced user operations and validation on the core side, making it beneficial for both ends.

BoneConstraint3D (and 3 child classes)

BoneConstraint3D is a feature that allows bones to interact with other bones. The actual behavior and calculations it provides are simple.

What was challenging here was the design for a base class containing a virtual struct array as a member and extending that struct in a child class. This topic is a bit more advanced for beginner coders, but when using struct arrays as properties in Godot, you need to implement a slightly tricky approach.

I already had the design idea that IK would have a base class similar to BoneConstraint3D, with child classes extending the structure to implement the actual solver. So, I was confident that merging and establishing that method at this point would be beneficial for IK.

Godot 4.6

Finally, I began implementing IK in Godot 4.6.

IKModifier3D (and 7 child classes)

As a first step, I defined IKModifier3D and ChainIK3D by reusing BoneConstraint3D and SpringBoneSimulator3D. After that, I implemented the process for moving joints called the IK solver.

Therefore, IKModifier3D has the following child classes:

IKModifier3D
- TwoBoneIK3D
- ChainIK3D
  - SplineIK3D
  - IterateIK3D
    - FABRIK3D
    - CCDIK3D
    - JacobianIK3D

When implementing those IKs, I made sure to keep them to the minimum functions.

Some IK systems outside of Godot might have additional “processing to make the IK results look better”, separate from the core calculation algorithm that rotates the bones. In the rich IK system, the IK class may include them and can enable their processing by their bool property.

Then, I believed separating them would help maintain maintainability and extendability. In other words, if only the “processing to make the IK results look better” can be reused, when users want to implement custom IK, they only need to implement a minimal IK solver.

The following are the improvements and additions made in Godot 4.6 to make the IK results look better.

Tweak BoneConstraint3D

For example, there are cases where Twist is applied before IK calculation, or where the end bone is directed toward the IK target after IK calculation.

In Godot 4.5, the BoneConstraint3D could only assign bones as reference objects, but in 4.6, it can now assign Node3D objects.

This tweaking allows BoneConstraint3D to be used to perform these additional rotations.

adjusted-ik-3d-demo.zip

BoneTwistDisperser3D

In theory, using ConvertTransformModifier3D allows you to apply the rotation of descendant bones to their ancestors. However, the process for setting this up properly was somewhat complex and could only be handled by advanced users.

BoneTwistDisperser3D provides a simple way to achieve that process.

LimitAngularVelocityModifier3D

LimitAngularVelocityModifier3D is a modifier that limits angular velocity. The behavior is quite simple, so it doesn’t need much explanation.

However, it’s worth learning that there are two types of IK.

Deterministic IK

In computer science, “deterministic” means that the result is always the same for a given input. In particular, for game applications like Godot, the term means that the result does not depend on the state of the previous frame. Incidentally, since AnimationMixer already has a deterministic option, that immediately made me decide to adopt this term.

TwoBoneIK3D and SplineIK3D are always deterministic. However, in IterateIK3D, whether it is deterministic depends on the options.

IterateIK3D repeats the routine provided by the solver to approach the end bone toward its goal. At this point, the number of repetitions per frame depends on the option.

When the deterministic option is disabled, it means that the iteration is performed by carrying over the state from the previous frame. In this case, even with a small number of iterations per frame, the end bone can reach the goal eventually as frames progress.

In contrast, when the deterministic option is enabled, the previous frame’s state is not carried over. Therefore, if the number of iterations per frame is small, the end bone may never reach its goal.

However, if you want to ensure consistent results depending on the relative position between the IK target and the skeleton, the deterministic option is useful. For example, it is ideal for online applications where only the coordinates of the IK target are shared to synchronize the model’s pose.

As a point to note, deterministic IK cannot avoid causing rotation with large angular velocities by its design. It goes without saying that LimitAngularVelocityModifier3D is useful for smoothing this out.

Looking back on the journey

Between versions 4.4 and 4.6, excluding migrations, including base classes, 19 new SkeletonModifiers have been implemented!

There are many possibilities depending on how you combine them. So we have a plan to add detailed explanations and tutorials to the documentation in the future, but since that is expected to be quite large, we will need more time…

For now, I’ll show you just one example in advance. This setup emulates the old SkeletonIK3D’s magnet option.

magnet-ik-3d-demo.zip

As you can see from that example, it was just a 2-pass deterministic FABRIK. As explained above, it was also “processing to make the IK results look better”, and I think you can understand that the process could be separated.

At last, I wish you all the best in creating fun games using SkeletonModifier3Ds.

Support

Godot is a non-profit, open-source game engine developed by hundreds of contributors in their free time, as well as a handful of part or full-time developers hired thanks to generous donations from the Godot community. A big thank you to everyone who has contributed their time or their financial support to the project!

Dev snapshot: Godot 4.6 beta 1

2025-12-10T12:00:00+00:00

It’s finally time for the 4.6 release cycle to feature its very first beta! Thanks to handling the feature freeze in dev 6, there are already been several bugs and regressions identified early and subsequently squashed. However, there are still more to iron out, so all contributors are encouraged to shift their focus to regression fixes exclusively.

For those interested in aiding us on our quest to squash any bugs that come up during this time, we once again encourage you to join our bug-hunting sprints. Anyone interested should read the Bug Triage Introduction for more information, and join the #bugsquad and #bugsquad-sprints channels on our developer RocketChat to participate!

The cover illustration is from Organized Inside, a slow-paced life simulator where you tidy up after your cat and your life. You can buy the game or download the demo for free on Steam, and check out the developers at Twitter or YouTube!

Highlights

For those who have been following our development snapshots closely, you may be familiar with a number of the highlights in this post which were already covered in previous articles (dev 1, dev 2, dev 3, dev 4, dev 5, and dev 6).

Because we’re already in feature freeze, there are no new features to cover compared to dev 6. Instead, we’ll focus on a general round-up of what to expect from Godot 4.6 as a whole, as well as expanding on some additions that we didn’t have the chance to highlight in our previous snapshots.

Breaking changes
Animation
Audio / Video
Core
Documentation
Editor
GDExtension
GDScript
GUI
Import
Input
Internationalization
Navigation
Physics
Platforms
Rendering and shaders
XR

Breaking changes

We try to minimize breaking changes, but sometimes they are necessary in order to fix high-priority issues. Where we do break compatibility, we do our best to make sure that the changes are minimal and require few changes in user projects.

You can find a list of such issues by filtering the merged PRs in the 4.6 milestone with the breaks compat label. Here are some which are worth being aware of:

Default glow blend mode has changed to screen and default glow levels have changed (GH-110671 and GH-110077).
- Note: Glow blending now occurs before tonemapping and softlight glow blending has changed to always appear as it did when using HDR 2D on your Viewport.
Quaternion now correctly initializes with identity under Variant (GH-84658).

If you previously imported 3D assets, we recommend using the project upgrade tool explicitly:

Animation

Tokage has brought IK support for SkeletonModifier3D via the new class IKModifier3D (GH-110120). This took the lessons learned from SkeletonModificationStack3D, a class removed in the 4.0 transition, and reimplemented them in a context that’s up to modern standards. Having to account for so many separate systems resulted in SkeletonModifier3D receiving 8 new subclasses:

IKModifier3D
- ChainIK3D
  - IterateIK3D
  - SplineIK3D
- TwoBoneIK3D

And more:

Add BoneTwistDisperser3D to propagate IK target’s twist (GH-113284).
Add LimitAngularVelocityModifier3D to interpolate deterministic IK (GH-111184).
Add option to BoneConstraint3D to make reference target allow to set Node3D (GH-110336).
Add solo/hide/lock/delete buttons to node groups in bezier track editor (GH-110866).
Allow resizing the length of animations by dragging the timeline (GH-110623).
Change AnimationLibrary serialization to avoid using Dictionary (GH-110502).

Audio / Video

Julian Todd added new experimental functions to AudioServer to allow accessing the microphone buffer directly (GH-113288). This allows individual platforms to access the input and output streams in a way that doesn’t assume a uniform rate, something that’s not guaranteed on all devices.

Core

Gergely Kis, Gábor Koncz and Ben Rog-Wilhelm have laid out a foundation for building the engine as a standalone library: LibGodot (GH-110863). Through the new GodotInstance class, developers now have an entry point for specialized workflows that absolutely require accessing Godot as a library.

Lukas Tenbrink has brought tracing profiler support to Godot (GH-104851). With this, engine developers will no longer need to manually integrate (and constantly re-integrate) profiling logic to the engine, as they are now officially integrated within the build system instead. There is currently support for Tracy, Perfetto, and Apple Instruments’ signposts (GH-113342).

As in every version, contributors come together to improve the stability and performance of some of Godot’s most used foundational building blocks — For example, you can expect a decrease of RAM use when opening files (GH-106039), a boost of speed when sorting arrays (GH-113132), accelerated Object casts (GH-105793), and decreased build time (GH-111218).

And more:

Add ‘Find Sequence’ to Spans, and consolidate negative indexing behavior (GH-104332).
Add change_scene_to_node() (GH-85762).
Add reserve function to Array, Vector, and String (GH-105928).
Add ability to get list of Project Settings changed, similar to Editor Settings functionality (GH-110748).
Add unique Node IDs to support base and instantiated scene refactorings (GH-106837).
Buildsystem: SwiftUI lifecycle for Apple embedded platforms (GH-109974).
Export: Add “Show Encryption Key” toggle (GH-106146).
Export: Add support for delta encoding to patch PCKs (GH-112011).
FileAccess: Implement support for reading and writing extended file attributes/alternate data streams (GH-102232).
Handle NaN and Infinity in JSON stringify function (GH-111498).
Network: Add Core UNIX domain socket support (GH-107954).

Documentation

Tomasz Chabora updated our documentation logic to not expose signals with a leading underscore (GH-112770). Not being exposed in this manner also means that they won’t show up as autocompletion results. This is consistent with how we handle methods, and will remove the need for users to work around bloating their documentation with add_user_signal().

Editor

The long-time fan-favorite Godot Minimal Theme, created by passivestar, is now officially integrated as the new default theme for the editor. As a collaborative effort between passivestar and Michael Alexsander, the theme has been brought to a new life under the name “Modern Theme” (GH-111118). The previous style remains available as the “Classic Theme,” and will continue to be supported.

The new theme is still actively iterated upon to iron out some issues and take user feedback into account. If you would like to share your thoughts, you can use this GitHub discussion or this Bluesky thread.

In a similar vein to the previous point, we’ve applied a similar minimal-style overhaul to the array inspector. This change is inherent to the inspector itself, so the benefits will be shown regardless of which theme is chosen. Koliur Rahman brought us this revamped implementation, trimming away wasted space by consolidating information and logic to their essential elements (GH-103257).

Old	New

Tomasz gave the editor docks a major rework (GH-106503). A new EditorDock class was introduced, which is responsible for handling dock appearance and supported dock slots, and makes it easier to switch dock layouts and save their data. EditorDock inherits MarginContainer and is supposed to be used as a root node of your docks. Of course all necessary compatibility code was added, so old plugins will still work without any changes.

Another important part of this rework came to us from lodetrick, whereby the bottom panel is now part of the docking system, so all bottom editors are now docks and docks can be freely moved between sides and bottom (GH-108647). Note that most docks don’t support both layouts (yet), but they all can be made floating (except Debugger), and the persistent docks can be closed. The docking system is planned to be improved further in the future, including a potential rework of main screen editors into docks for further unification.

The 3D viewport received several long-requested functionality commonly available in modern 3D modeling programs. Robert Yevdokimov added a means of visualizing the current delta angle of a rotation operation, a convenient reference point for adjusting objects in a 3D space. passivestar added orbit-snapping within the viewport itself, enabling more granular positioning and consistent feedback.

And more:

2D: Add support for rotating scene tiles in TileMapLayer (GH-108010).
3D: Add Bresenham Line Algorithm to GridMap Drawing (GH-105292).
3D: Rename Select Mode to Transform Mode, and create a new Select Mode without transform gizmo (GH-101168).
Add an ObjectDB Profiling Tool (GH-97210).
Add Create Resource Hotkey (GH-110641).
Add drag and drop export variables (GH-106341).
Add game speed controls to the embedded game window (GH-107273).
Add indicator to linked resources (GH-109458).
Add switch on hover to TabBar (GH-103478).
Add tab menu button to list currently opened scenes (GH-108079).
Allow drag setting flags in layers property editor (GH-112174).
Allow editing editor settings from project manager (GH-82212).
Allow editing groups on multiple nodes (GH-112729).
Allow fixing indirect missing dependencies manually (GH-112187).
Allow Quick Open dialog to preview change in scene (GH-106947).
Automatically open newly created script (GH-108342).
Make file part of errors/warnings clickable in Output panel (GH-108473).
Move script name to top (GH-86468).
Open source code errors in external editor (GH-111805).
Show a warning toast when saving a large text-based scene (GH-53679).

GDExtension

Through a collaborative effort between David Snopek and Thaddeus Crews, it’s now possible to declare Object types as “required” (GH-86079). This information is passed as GDExtension metadata, meaning that nullable-aware languages no longer need to assume that every Object class is inherently optional. This implementation does not break compatibility, as it still passes/receives the same data under the hood.

David has also changed the canonical source-of-truth for GDExtension from a C header (gdextension_interface.h) to JSON (gdextension_interface.json) (GH-107845). This simplifies the GDExtension workflow, and allows additional information to be included in the interface. For example, GDExtension bindings will now be able to declare builtin functions as deprecated to GDExtension programmers (GH-112290).

GDScript

Lukas continued his dedicated profiler integration by collaborating with Samuel Nicholas to bring native support to GDScript (GH-113279). While currently limited to tracy, this is a major first step in allowing dedicated profilers to be a universal solution for debugging performance. If you’re eager to try this yourself, you can find instructions for it in our docs already, contributed by David.

And more:

Add debug/gdscript/warnings/directory_rules project setting (GH-93889).
Add opt-in GDScript warning for when calling coroutine without await (GH-107936).
Add step out to script debugger (GH-97758).
Add string placeholder syntax highlighting (GH-112575).
Elide unnecessary copies in CONSTRUCT_TYPED_* opcodes (GH-110717).
GDScript LSP: Rework and extend BBCode to markdown docstring conversion (GH-113099).
Prevent shallow scripts from leaking into the ResourceCache (GH-109345).

GUI

Michael has brought another new addition: the focus state logic for mouse and touch is now decoupled from keyboard and joypad (GH-110250). As we mentioned in the 4.6 dev 1 blog post, it’s not uncommon for systems to deliberately stylize these two input groups separately, enabling granular control for toolmakers and UI designers. Controls that support keyboard input (LineEdit, TextEdit, etc.) will show focus by default in a running project.

Situation
Clicking a `Control` with the mouse, giving it focus.	❌
Successfully switching focus via keyboard/joypad actions.	✔️
Attempting to switch focus via keyboard/joypad actions but still remaining on the same `Control`.	✔️
Clicking somewhere with the mouse while having a `Control` with visible focus.	❌
Clicking with the mouse a visibly focused `Control` (deviates from how it works in browsers).	❌
Using `Control.grab_focus(true)`.	❌

The previous behavior can be achieved by enabling gui/common/always_show_focus_state.

And more:

Add pivot_offset_ratio property to Control (GH-70646).
Add scroll hints to ScrollContainer and Tree (GH-112491).
- ItemList also supports scroll hints as of GH-113574.
Allow customization of TabContainer tabs in editor (GH-58749).
Optimize CPU text shaping (GH-109516).
Separate Node editor dock (GH-101787).
Speed up very large Trees (GH-109512).
Visualize MarginContainer margins when selected (GH-111095).

Import

Arseny Kapoulkine has addressed a previous shortcoming of our mesh simplifier by ensuring the components themselves are simplified alongside collapsing edges (GH-110028). This enables topologically complex sections of a larger mesh to more easily reach the desired LOD target.

And more:

Betsy: Convert RGB to RGBA on the GPU for faster compression (GH-110060).
OBJ importer: Support bump multiplier (normal scale) (GH-110925).
Switch LOD generation to use iterative simplification (GH-110027).

Input

Nintorch, the contributor responsible for migrating our input system to SDL3, has laid the foundation for advanced joypad features in Godot (GH-111707). The only functionality this enables at this time is the customization of LED light colors (GH-111681), but he’s already created additional PRs that will implement support for motion sensors, adaptive triggers, and custom data packets, which is only scratching the surface of possible functionality in future releases.

And more:

Add ability to add new EditorSettings shortcuts (GH-102889).

Internationalization

Haoyu Qiu saw to the improvement of CSV translations (GH-112073). This introduces support for optional ?context and ?plural columns, where the former passes crucial information to translators, while the latter declares plural equivalents to sentences. Plurals can be further expanded via ?pluralrule, which allows for further customization of languages with more complex plural specifications.

en	?context	fr	ru	zh
Letter	Alphabet	Lettre	Буква	字母
Letter	Message	Courrier	Письмо	信件

en,?context,fr,ru,ja,zh
Letter,Alphabet,Lettre,Буква,字母,字母
Letter,Message,Courrier,Письмо,手紙,信件

en	?plural	fr	ru	zh
?pluralrule		nplurals=2; plural=(n >= 2);
There is %d apple	There are %d apples	Il y a %d pomme	Есть %d яблоко	那里有%d个苹果
		Il y a %d pommes	Есть %d яблока
			Есть %d яблок

en,?plural,fr,ru,ja,zh
?pluralrule,,nplurals=2; plural=(n >= 2);,,
There is %d apple,There are %d apples,Il y a %d pomme,Есть %d яблоко,リンゴが%d個あります,那里有%d个苹果
,,Il y a %d pommes,Есть %d яблока,,
,,,Есть %d яблок,,

stark233 brought proper translation parser support to C# scripts (GH-99195). Now internationalization string collections will have the same functionality as GDScript, alongside native integration with GodotTools.

And more:

Add CSV translation template generation (GH-112149).
Make editor language setting default to Auto (GH-112317).

smix8 has opened the door to engine backend selection for NavigationServers (GH-106290). While Godot doesn’t have additional navigation backends at this time, this does grant users a way to effectively disable the servers entirely via Dummy, removing the need to recompile the engine entirely for games that don’t require navigation systems for 2D and/or 3D.

Physics

Mikael Hermansso has done an absolutely phenomenal job with integrating Jolt as a first-class physics system for Godot. It’s now at the point where we can confidently remove its experimental label (GH-111115) and select it as the default for any newly-created projects (GH-105737). This does not apply retroactively, but any projects made from this point on will be using Jolt out-of-the-box.

And more:

Add MeshInstance3D primitive conversion options (GH-101521).
Add MultiMesh physics interpolation for 2D transforms (MultiMeshInstance2D) (GH-107666).

Platforms

Android

Anish Kumar took to the implementation of Storage Access Framework (SAF) support (GH-112215). Previously, accessing non-media files on external storage required the MANAGE_EXTERNAL_STORAGE permission, which is very broad and discouraged by Google. Now, projects can access files through the system’s file picker instead, and this method doesn’t require any permissions at all!

Thanks to the efforts of David Snopek and Logan Lang, Godot is now able to initiate Gradle builds on Android (GH-111732). By sending commands to a companion app that provides a full Linux-like build environment to run Gradle, Godot itself remains lightweight while keeping setup easy by including everything you need within the companion app.

And more:

Editor: Add game speed control options in game menu bar (GH-111296).
Editor: Adjust script editor size for virtual keyboard (GH-112766).
Editor: Persist fullscreen setting (GH-112246).
Export: Add export option to use “scrcpy” to run project from editor (GH-108737).
Tests: Add Android instrumented tests to the app module (GH-110829).

Linux

Deralmas has continued on their quest to make Wayland a first-class window protocol with the exciting introduction of game embedding (GH-107435). This was one of the final major roadblocks that kept us from confidently declaring Wayland’s feature-parity with X11, and neatly rounds out the last major holdout towards embedded-window support across all major platforms.

And more:

Wayland: Implement the xdg-toplevel-icon-v1 protocol (GH-107096).

Windows

Skyth was tasked by the Godot Foundation to bring Direct3D 12 to feature and stability parity with Vulkan, so that we could make it the default RenderingDevice driver on Windows (GH-113213). As a result, Windows users can safely sidestep issues with comparatively outdated Vulkan drivers, as Direct3D 12 is the mainstay renderer for modern programs and API kits.

And more:

Fix EnumDevices stall using IAT hooks (GH-113013).

Rendering and shaders

Allen Pestaluky has been hard at work implementing features which will allow Godot to take full advantage of HDR. Luckily for those stuck with sRGB displays, his efforts have been in the form of visual quality improvements for everyone! Perhaps his most obvious improvement was a result of modifying blend glow to occur before tonemapping and changing the default blend mode behavior to screen (GH-110671).

Before PR (glow after tonemapping)	After PR (glow before tonemapping)

But you’ve already seen this if you’ve been keeping up with our previous development snapshots. What we haven’t had the chance to showcase is the addition of white, constrast, and future HDR support for the AgX tonemapper (GH-106940). Allen once again has brought us exciting new visual possibilities with this functionality, as this allows for the hue of bright colors to be more consistent, even at higher contrasts. Crucially, the new changes do not break compatibility with existing 4.4 and 4.5 projects, as the new curves this system provides were setup such that their visuals are in-line with the old AgX approximations.

Scenes using glow or the AgX tonemapper will see improvements to the overall visual quality.

AgX default contrast	AgX contrast of `1.53`

Before	After

Skyth overhauled our screen space reflection logic, resulting in higher quality visuals at a reduced performance cost (GH-111210). We feel that the results speak for themselves.

64 Max Steps (old)	64 Max Steps (new - half) (half)	64 Max Steps (new - full)

256 Max Steps (old)	256 Max Steps (new - half)	256 Max Steps (new - full)

Roughness (old)	Roughness (new)

Metallic surface (old)	Metallic surface (new - half)	Metallic surface (new - full)

It’s not all 3D improvements though, as Stuart Carnie overhauled the design of our 2D renderer to reduce the GPU performance cost when batching (GH-112481). This resulted in better performance across all devices (in GPU-bound scenarios), producing speeds ranging from 1.1x to 7x as fast. The actual benchmarks and more technical details are available in the associated pull request.

And more:

Add methods to draw ellipses (GH-85080).
Apply viewport oversampling to Polygon2D (GH-112352).
Implement a very simple SSAO in GLES3 (GH-109447).
Implement motion vectors in compatibility renderer (GH-97151).
Overhaul and optimize Glow in the mobile renderer (GH-110077).
Rewrite Radiance and Reflection probes to use Octahedral maps (GH-107902).
TAA adjustment to reduce ghosting (GH-112196).

XR

Bastiaan Olij has brought native support for OpenXR 1.1 to Godot, which will automatically enable OpenXR 1.1 features on devices that support it (GH-109302). This comes with a compatibility layer to make this as transparent as possible for developers who want to deploy their games both to headsets that support OpenXR 1.1, and those that only support OpenXR 1.0.

Bastiaan additionally implemented support for OpenXR Spatial Entities Extensions, introduced to standardize obtaining and interacting with information about the user’s real world environment (GH-107391). This brings support for spatial anchors, plane tracking, and marker tracking in a consistent and platform-independent manner. If you have the necessary equipment for it, Bastiaan has provided a demo project to showcase this new functionality.

David Hover took to supporting the extensions for offsetting density maps (GH-112888). This is a key feature enabling eye-tracked foveated rendering on devices that support this method. Currently, this has been tested on Meta Quest Pro and Samsung Galaxy XR headsets, but other headsets are expected to benefit from this change as well.

David added support for the XR_KHR_android_thread_settings extension, which informs the XR runtime about threads used for rendering, game logic, or other purposes (GH-112889). This allows for better thread prioritization on AOSP devices that implement this extension.

And more:

Add support for Android XR devices to the Godot XR Editor (GH-112777).
OpenXR: Add core support for Khronos loader (GH-106891).
OpenXR: Add support for frame synthesis (GH-109803).
OpenXR: Add Valve Steam Frame controller support (GH-113785).

Changelog

328 contributors submitted 1483 fixes since the release of 4.5-stable. See our interactive changelog for the complete list of changes. You can also review changes since the 4.6-dev6 snapshot, for a more curated selection of 52 fixes from 29 contributors.

This release is built from commit d743736f8.

Downloads

Download Godot 4.6 beta1

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

With every release, we accept that there are going to be various issues which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Donate now

Dev snapshot: Godot 4.6 dev 6

2025-12-05T12:00:00+00:00

Woah, two development snapshots in the same week? Indeed, we’re gonna be handling the transition to the beta stage a little differently this time around.

During the development pipeline of Godot 4.x, we developed a bit of a bad habit by starting the feature freeze AT the first beta release. While not inherently bad, this did lead to somewhat bloated blog posts that had to juggle both newly-added features and the more general feature roundup for the release as a whole. So while this format may work for some organizations, we’re trying something new by implementing the feature freeze preemptively. As of this moment: Godot 4.6 is in feature freeze, and dev 6 will be our final development snapshot.

A big benefit of this is the ability to isolate the big additions and fixes for the final new features that made it over the finish line in time. So while this will be a smaller roundup than usual, there’s still plenty of exciting additions we’re eager to showcase.

The cover illustration is from WAR RATS: The Rat em Up, a tactical shoot ‘em up, where you lead your fearless troops in the Great Rat War against the onslaught of the TechnoRat legion. You can get the game on Steam, and check out the developers on Twitter or Instagram!

Highlights

GDScript: Tracy profiler support

In the 4.6 dev 4 blog post, we had a section featuring dedicated profiler support. That section was written for more technical users that were already familiar with how dedicated profilers operated, so it focused on their immediate benefit of profiling the C++ code of the Godot Engine itself. In hindsight, we could’ve expanded it to be more readable for the average user, as this system had the potential to expand to profiling well beyond our system internals. It was ultimately considered superfluous, as no such integrations existed, and implementing them in a handful of weeks before feature freeze was extremely unlikely.

…You read the header, you know where this is going. Lukas Tenbrink, the original implementer of dedicated profiler support, collaborated with enetheru to bring this native support to GDScript (GH-113279)! While currently limited to tracy, this is a major first step in allowing these dedicated profilers to be a universal solution for debugging performance.

Documentation on how to utilize these native profilers yourself will soon be available here (currently in PR form).

Android: Storage Access Framework support

Godot apps on Android have this unfortunate hurdle of effectively requiring the MANAGE_EXTERNAL_STORAGE permission. Without it, users were limited to files within the Documents/Download directories that the app itself created. Despite other scoped permissions being available for media files (READ_MEDIA_IMAGES, READ_MEDIA_AUDIO, and READ_MEDIA_VIDEO), non-media files (.txt, .json, etc) still required the special MANAGE_EXTERNAL_STORAGE permission. While workarounds did exist, the best solution would be one that sidesteps the issue entirely.

syntaxerror247 has brought a solution in the form of implementing full Storage Access Framework (SAF) support (GH-112215). With the addition of SAF, users are now free to open and save files from any directory with the system file picker. Because the system itself handles the logic for permissions, the app no longer needs to concern itself with requesting explicit permissions from the end-user.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

Animation: Add BoneTwistDisperser3D to propagate IK target’s twist (GH-113284).
Animation: Add solo/hide/lock/delete buttons to node groups in bezier track editor (GH-110866).
Audio: AudioServer to have function to access microphone buffer directly (GH-113288).
Core: Add Apple Instruments support (GH-113342).
Core: Reuse/optimize common OperatorEvaluator*::evaluate logic (GH-113132).
GDScript: Prevent shallow scripts from leaking into the ResourceCache (GH-109345).
GUI: Add scroll hints to ScrollContainer and Tree (GH-112491).
GUI: Make EditorFileDialog inherit FileDialog (GH-111212).
Rendering: Add white, contrast, and future HDR support to the AgX tonemapper (GH-106940).
Rendering: Implement point size emulation in the forward shader for D3D12 (GH-112191).
Rendering: Rewrite Radiance and Reflection probes to use Octahedral maps (GH-107902).
Rendering: Use re-spirv in the Vulkan driver to optimize shaders (GH-111452).

Changelog

67 contributors submitted 140 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-dev5. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit dec5a373d.

Downloads

Download Godot 4.6 dev6

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Godot is a non-profit, open source game engine developed by hundreds of contributors on their free time, as well as a handful of part and full-time developers hired thanks to generous donations from the Godot community. A big thank you to everyone who has contributed their time or their financial support to the project!

Donate now

Dev snapshot: Godot 4.6 dev 5

2025-12-01T12:00:00+00:00

As the Northern Hemisphere’s days get shorter and colder, we get closer to our much anticipated feature freeze. Dev 5 is jam-packed with new features and enhancements as contributors try to finish off their big contributions before we hit the feature freeze and Beta 1 shortly after. As a reminder, feature freeze is the period where we stop merging anything except for bug fixes as we shift our focus to polishing the existing code in preparation for release. We plan on entering our feature freeze on December 3 and only releasing one more dev snapshot before entering the Beta phase.

The cover illustration is from Kingdoms of the Dump, a SNES-inspired JRPG where Trash Can Knight, a trash can knight, guides their party through a fantasy world of garbage. You can get the game on Steam, and check out the developer websites for Roach Games and Dream Sloth Games. Notably: this title was created using Godot 2.1!

Highlights

Use D3D12 by default on Windows

Ever since its addition in Godot 4.3 by RandomShaper and further refinement by DarioSamo, Direct3D 12 has been a mainstay renderer for supported devices (Windows). This is because Vulkan is unfortunately unstable on Windows, with GPU drivers being poorly maintained compared to their Direct3D 12 counterparts. As such, for the 4.6 release cycle, Skyth was sponsored by the Godot Foundation to make Direct3D 12 the default RenderingDevice driver on Windows. His efforts paid off, and the change was integrated just before feature freeze (GH-113213).

This will only impact new projects created in 4.6-dev5 or later. To use this new default in pre-existing Godot 4.5 projects, you should set the rendering/rendering_device/driver.windows project setting to d3d12 manually.

Add support for delta encoding to patch PCKs

In Godot 4.4 we introduced the ability to export PCK files as a patch PCK, by letting you provide a set of base PCK files with which to compare against, and then only export the files that had actually changed since then. While this isn’t strictly needed when dealing with most of the major distribution platforms, since they will often distribute only the minimal difference between any two releases anyway, it can become important if you’re distributing content patches through your own means, where things like disk space, bandwidth costs and metered connections come more into focus.

However, while this initial implementation did allow for much smaller PCK files compared to exporting everything, it was still an all-or-nothing deal on a per-file level. This meant that if you changed just a single character in some localization string, you would end up exporting the entire localization file for that language, which can potentially be dozens of megabytes in size. This also applied to certain metadata files that Godot manages behind the scenes, which can grow quite big in large-scale projects, and which would be modified anytime you added or removed resources.

To help with this, Mikael Hermansson added support for what’s called “delta encoding”, also known as “binary patching” or “binary diffing” (GH-112011). This is the same technique used by the major distribution platforms in order to figure out what the minimal difference is between the latest release and the one you have installed, where you simply compare two arbitrary files (binary or otherwise) and try to extract the minimal set of changes from it. This means that you can now optionally export only the parts of a file that actually changed since your last patch, meaning changing a single character in some localization string results in a patch that’s on the order of a few dozen bytes, as opposed to megabytes.

Note that this feature must be explicitly enabled, under the “Patching” tab in the export dialog, because it comes with a slight runtime overhead when patches are applied, which they are every time a patched file is loaded. This overhead can be as much as a few milliseconds in the worst case.

Dedicated build app for Gradle builds on Android

Godot supports two ways to export to Android: injecting your game’s data into a pre-built APK (the default) or by running the Gradle build system, which is how native Android apps are usually built.

Modifying the pre-built APK is faster and requires less setup, but is more limited. If you want to use Godot Android Plugins to integrate, for example, Google Play Billing, AdMob, or build an XR app, you need to use Gradle.

While the Godot editor itself runs on Android, allowing you to develop games on your phone or tablet, it has only ever supported exporting via the pre-built APK… until now!

Thanks to the efforts of David Snopek and Logan Lang in GH-111732, Godot is now able to initiate Gradle builds on Android, by sending commands to a companion app that provides a full Linux-like build environment to run Gradle. Using a companion app allows us to make setup easy by including everything you need within the app, while keeping Godot itself lightweight. We plan to release the app on Google Play and other Android stores before Godot 4.6 stable is released, but for now you can download an APK from the PR.

Moving OpenXR forward

Godot now supports OpenXR 1.1 and will automatically enable OpenXR 1.1 features on devices that support this (GH-109302). This comes with a compatibility layer to make this as transparent as possible for developers who want to deploy their games both to headsets that support OpenXR 1.1, and those that only support OpenXR 1.0.

The OpenXR loader logic for AOSP platforms has moved from the vendor plugin into the core (GH-106891). Godot can now export to any supported OpenXR platform without relying on any plugins. This enables creating and distributing a single APK that runs on nearly all AOSP devices, a potential game changer for tutorial makers and developers who target vendor-agnostic stores like itch.io. The Godot OpenXR vendor plugin remains an important first-party plugin that enables the use of vendor extensions and implements support for specific vendor permissions and feature settings.

Massive optimizations to the 2D renderer

In Godot 4.4 we introduced automatic 2D batching which is an optimization that saves a huge amount of CPU resources by drawing similar objects in a single draw call. 2D batching results in huge wins for content that can easily be batched, like text-heavy games or bullet hells.

Batching doesn’t come without a cost, when the batching system is unable to create any batches, then it adds a performance cost, but doesn’t improve performance. It also makes rendering slightly more expensive for the GPU.

In our testing we found that most scenes we tested were CPU-bottlenecked, so the increase in GPU cost did not make a noticeable difference, and where it did, the decrease in performance was very small.

However, over time we have had a few concerning reports of 4.4 being significantly slower than 4.3, especially on older and lower-end mobile devices. These devices also tended to be GPU-bottlenecked, which made the performance regression even more concerning.

In this release, we did a huge overhaul to the design of our 2D renderer to reduce the GPU performance cost when batching. The end result is significantly better performance on a range of hardware. In our testing this change has resulted in improved performance on all devices (in GPU-bound scenarios) ranging from 1.1x to 7x as fast.

To read more and see the benchmarks, check out the pull request.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

2D: Add support for rotating scene tiles in TileMapLayer (GH-108010).
Animation: Add option to BoneConstraint3D to make reference target allow to set Node3D (GH-110336).
Animation: Change AnimationLibrary serialization to avoid using Dictionary (GH-110502).
Core: Add RequiredParam<T> and RequiredResult<T> to mark Object * arguments and return values as required (GH-86079).
Core: Fix EnumDevices stall using IAT hooks (issue with certain USB peripherals) (GH-113013).
Core: Implement support for reading and writing extended file attributes/alternate data streams (GH-102232).
Editor: Add “Use Local Space” option to the 2D editor (GH-107264).
Editor: Add ability to add new EditorSettings shortcuts (GH-102889).
Editor: Add expression history to evaluator (GH-108391).
Editor: Add tab menu button to list currently opened scenes (GH-108079).
Editor: Allow customization of TabContainer tabs in editor (GH-58749).
Editor: Allow dragging setting flags in layers property editor (GH-112174).
Editor: Allow editing groups on multiple nodes (GH-112729).
Editor: Allow resizing the length of animations by dragging the timeline (GH-110623).
Editor: Make bottom panel into available dock slot (GH-108647).
Editor: Make rotation gizmo white outline a 4th handle that rotates around the camera’s view-axis (GH-108608).
Editor: Move History dock to the bottom left by default (GH-112996).
Editor: Rename Select Mode to Transform Mode, and create a new Select Mode without transform gizmo (GH-101168).
Editor: Separate Node editor dock into two new docks: Signals and Groups (GH-101787).
Editor: Show a warning toast when saving a large text-based scene (GH-53679).
GDExtension: Store source of gdextension_interface.h in JSON (GH-107845).
GDScript: Add debug/gdscript/warnings/directory_rules project setting (GH-93889).
GDScript: Add step out to script debugger (GH-97758).
GDScript: LSP: Rework and extend BBCode to Markdown docstring conversion (GH-113099).
GUI: Allow SplitContainer to have more than two children (GH-90411).
Platforms: Android: Adjust script editor size for virtual keyboard (GH-112766).
Platforms: Wayland: Implement game embedding (GH-107435).
Rendering: Refactor rendering driver copy APIs to fix several D3D12 issues (GH-111954).
Rendering: TAA adjustment to reduce ghosting (GH-112196).
XR: Add support for Android XR devices to the Godot XR Editor (GH-112777).
XR: Implement XR_KHR_android_thread_settings (GH-112889).
XR: Implement XR_META_foveation_eye_tracked (GH-112888).
XR: OpenXR: Add profiling macro for process, xrWaitFrame() and acquiring swapchain (GH-112893).

Changelog

134 contributors submitted 323 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-dev4. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit f5918a9d3.

Downloads

Download Godot 4.6 dev5

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Donate now

Godot XR update - November 2025

2025-11-21T12:00:00+00:00

“The Museum of All Things” released on the Meta Quest store!

The Museum of All Things is a virtual museum where each exhibit is generated from an article on Wikipedia, and the links to other articles become doors to other exhibits.

It was the topic of a showcase back in February, where it had a PCVR version, but no port to the Meta Quest.

However, now it’s launched on the Meta Quest store!

Results of the Godot XR Community Game Jam

In September the Godot XR Community held its latest game jam and we had some amazing entries. The quality is definitely rising from previous jams.

The theme this time around was “It takes two”, and the interpretations of the theme did not disappoint.

You can find the full results here, we’ll list the top 5 results below. I highly recommend checking out the other entries. There are a number of gems that didn’t make the top 5.

No 5. “Rogue Vantage” by Allen Dawodu

Rogue Vantage by Allen Dawodu ranked 5th with 11 ratings (Score: 3.606).

This entry is a variation on the Superhot formula where time only progresses when you move.

However the main character is now an NPC that you need to assist. Levels get progressively more difficult as you’re trying to keep your NPC alive.

No 4. “And 2 We Are” by MigueBC

And 2 We Are by MigueBC ranked 4th with 10 ratings (Score: 3.617).

This entry has you play two separate characters that need to perform complimentary actions to escape a maze. It has a very Portal feel to it and I wish it had many more levels to it.

The miniaturization part was especially well executed.

No 3. “Runaway Rails” by Copper Tunic

Runaway Rails by Copper Tunic ranked 3rd with 11 ratings (Score: 3.833).

This great little rhythm game has you play together with another player to place rail road tracks to the beat of music in order to prevent a train from derailing.

If you don’t have a friend at hand, you can play together with an NPC.

The developer seems set to continue building this game out and has already released several updates to his game since the jam ended.

No 2. “Things You Can Do With Two Hands” by Matt Giuca

Things You Can Do With Two Hands by Matt Giuca ranked 2nd with 11 ratings (Score: 4.000).

This game might have a simple aesthetic, but it is a unique experience to play through.

The aim is to coordinate and perform actions with both your hands to complete levels. Whether it is turning keys in moving locks, throwing bowling balls that have to hit a cone at the same time, or trying to hit the moon while also hitting a target, it is deceptively tricky to complete the whole game.

No 1. “Wiener Wobble Dog Park” by Andyman404

Wiener Wobble Dog Park by Andyman404 ranked 1st with 7 ratings (Score: 4.048).

The winner of the game jam was Wiener Wobble Dog Park. This unique entry has you control a sausage dog with two fingers on each hand. One hand controls the front of the dog, while the other controls the rear.

The dog works like a slinky and you have to move it through an obstacle course where you can move only when the dog touches the course. It is a frantic and very enjoyable experience.

Introducing spatial entities

Spatial entities is a new collection of APIs within the OpenXR specification that gives us access to information about the real world around us. This API is designed to grow over time. Its initial iteration gives access to:

Spatial anchors allow users to mark real world locations that are tracked by the headset. These can be stored on the headset and retrieved on subsequent runs of your application. They are great for placing virtual objects in a fixed location in your real space.
Plane tracking provides us with insight about the world around us, where is our floor, where are walls, where are tables, etc.
Marker tracking allows us to use various printed markers like QR codes, April tags, and Aruca codes, and have our headset identify and track those locations.

Godot is an early adopter of this API thanks to funding through the Khronos Godot Integration Project.

You can try out this new API using the Galaxy XR headset as Android XR has support for all three implementations. We are eagerly awaiting news of other headsets supporting this functionality.

Frame synthesis

Frame synthesis is a new OpenXR API that defines a standard for advanced reprojection techniques. This allows you to run your application at a lower frame rate and have the runtime inject reprojected frames that use motion vectors and depth information to improve the image.

Note that this API only works with the Compatibility and Mobile renderers.

This work was made possible thanks to funding through the Khronos Godot Integration Project.

OpenXR inventory

The OpenXR working group maintains an inventory website where you can see which OpenXR extensions are supported on various OpenXR Runtimes.

The past year our very own Bastiaan Olij has spent time on extending this inventory to also support a client matrix showing which OpenXR extensions are supported by various game engines. Working together with developers from these other engines we were able to present a complete list and devise a system that will inform users of needed plugins to get access to these features.

We can now see that Godot leads the pack, supporting 95 official OpenXR extensions in total. This number is made up of:

14 core extensions (KHR)
22 multi-vendor extensions (EXT)
59 vendor extensions

Godot and W4 Games support Android XR from day One

2025-11-14T12:00:00+00:00

With the recent public release of Samsung Galaxy XR, the first headset using the new Android XR operating system, we are pleased to announce that Godot already supports this new ecosystem.

As a game engine that puts OpenXR front and center, Godot is uniquely positioned to excel on this platform.

With the release of the Godot OpenXR vendor plugin v4.2.0, a new option for Android XR has been added that allows developers using Godot 4.5 and newer to effortlessly export their existing projects to this new platform.

The Godot XR Editor has also been updated with Android XR support and runs beautifully on this new device. Users can download the Godot XR Editor from Google Play.

W4 Games has announced their support of the platform including implementing various vendor specific extensions that expose functionality unique to Android XR.

As part of this initiative, W4 Games will be making a donation to the Godot Foundation to ensure supporting Android XR long term and continue their work on enhancing Godot’s OpenXR support.

Dev snapshot: Godot 4.6 dev 4

2025-11-14T11:00:00+00:00

With GodotFest now behind us, it’s only natural that some users would be left with a sense of longing. Well we have just the thing: our most recent Godot 4.6 development snapshot! It’s not even been two weeks since the last one, but we couldn’t just leave y’all hanging for more Godot content. As always, these snapshots feature big changes, meaning they’re likely accompanied by big regressions and bugs; get those tests and reports in as early as possible to ensure an expedient release cycle!

The cover illustration is from House of Necrosis, a turn-based, horror RPG where you must survive the horrors of a mansion that changes every time it’s entered. You can get the game or try the demo on Steam, and follow the developer on YouTube, Bluesky, or itch.io.

Highlights

Animation: Add `SkeletonModifier3D` IKs as `IKModifier3D`

For those that aren’t already aware, SkeletonModificationStack3D was removed in the transition from 3.x to 4.0, as it was deemed wildly unstable and unsalvageable. Since then, Tokage has been on a journey to reincorporate the functionality such that it lives up to the standards the rest of the engine aims for. This started early last year with the incorporation of SkeletonModifier3D (GH-87888), which restored the majority of baseline functionality. However, there was one area which didn’t make the transiton: IKs.

The process of supporting IKs proved to be far more involved, as it too needed to be incorporated in a way that matched the engine’s standards and expectations. Consequently, that meant a solution that naturally expands off our Node paradigm; a tall order for how many use-cases and scenarios one must consider and account for when dealing with IKs. This resulted in SkeletonModifier3D receiving 8 new subclasses, which are as follows:

Attempting to go over all of these is well beyond the scope of this blog post, so readers wanting more information should check out the pull request for more details. Instead, we’ll show off one of the bugfixes to this new system in (GH-112573), as it provides an easily digestable visualization of what this system is capable of.

Before

After

Project manager: Various improvements

The editor received a lot of love this development snapshot, with many features well worth a look in the curated highlights. However, for this blog post, we’ll be focusing on an often overlooked element of our editor: the project manager. While technically separate from the editor in the traditional sense, it is editor-exclusive functionality which exists to launch project editors, so they’re invariably intertwined. With the project manager getting an uncharacteristic amount of attention this cycle, here’s a quick lightning-round of changes:

Rindbee is starting things off with an improved UI navigation (GH-101129). The previous implementation clashed with our recent AccessKit integration, as it didn’t lend itself to keyboard navigation. Now a new focus style makes navigation easier than ever:

Next is Malcolm Anderson, who implemented functionality for opening the project in the file explorer as a “Show in File Manager” button (GH-111624). Unfortunately, while a highly-requested feature, it proved to be too cluttered and was slated for a revert. Not being one to throw out the baby with the bathwater, Tomasz Chabora saved the functionality by reimplementing it in the form of a newly-added right-click menu:

Speaking of Tomasz, he’s here to round things off with yet another highly-requested feature: the ability to modify editor settings within the project manager (GH-82212). Now opening a project just to make general adjustments is no longer necessary, as it can all be handled in the much more lightweight context of the project manager:

Buildsystem: Support dedicated profilers

This is unapologetically super-nerd territory, and strictly targeting those who already know what this is talking about. Everyone else, feel free to jump to the curated highlights instead.

It’s rare for our blog posts to mention the buildsystem in any capacity — let alone as a featured highlight — but this is a very special exception: Godot can now natively support dedicated profilers GH-104851! Note that this is separate from Godot’s built-in profiler, as that’s suited for projects running in the engine, rather than the engine itself. Godot’s built-in profiler is still very useful, but these dedicated profilers are a great option for people who are very serious about optimizing Godot or their games.

Thanks to the efforts of Lukas Tenbrink, engine developers will no longer need to manually integrate (and constantly re-integrate) profiling logic to the engine. Instead, they merely need to pass the appropriate path to profiler_path, and our buildsystem will automatically detect and integrate the given profiler. Currently, the buildsystem supports Tracy and Perfetto, but the groundwork exists for additional tools to be integrated down the road.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

2D: Fix smart snapping lines to disappear after using the pivot tool (GH-105203).
3D: Add Bresenham Line Algorithm to GridMap Drawing (GH-105292).
Core: Add ability to get list of Project Settings changed, similar to Editor Settings functionality (GH-110748).
Editor: Add indicator to linked resources (GH-109458).
Editor: Allow concurrent unbinding and binding of signal arguments in editor (GH-108741).
Editor: Autoloads with UIDs (GH-112193).
Editor: Automatically open newly created script (GH-108342).
Editor: Fix edit resource on inspector when inside array or dictionary (GH-106099).
Editor: Open source code errors in external editor (GH-111805).
Editor: Persist fullscreen setting on Android Editor (GH-112246).
GUI: PopupMenu: Add theme option for merging icon and checkbox gutters (GH-112545).
I18n: Add CSV translation template generation (GH-112149).
I18n: Make editor language setting default to Auto (GH-112317).
Input: Add support for setting a joypad’s LED light color (GH-111681).
Rendering: Apply viewport oversampling to Polygon2D (GH-112352).
XR: OpenXR: Add support for frame synthesis (GH-109803).

Changelog

83 contributors submitted 168 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-dev3. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit bd2ca13c6.

Downloads

Download Godot 4.6 dev4

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

The newly released Visual Studio 2026 isn’t detected, instead falling back to VS2022/VS2019 GH-112675. There already exist a couple of potential solutions, so this will likely be resolved next update.

Additionally, SCons fails to detect/utilize Visual Studio 2026 when attempting a build. While not technically an engine issue, a number of contributors have expressed confusion over the lack of support, so it’s worth an explicit mention. This issue has since been resolved upstream, and will be incorporated in the next official release; anyone requiring the fix immediately should build SCons from the source repository.

Bug reports

Support

Donate now

Dev snapshot: Godot 3.7 dev 1

2025-11-13T12:00:00+00:00

Although the vast majority of contributors are busily working on Godot 4, a small problematic group refuse to stop improving Godot 3. Since Godot 3.6’s release in September 2024, we have been working hard on the new feature branch, 3.7.

Although a number of features are still in preparation, there have already been a number of improvements since 3.6, so consider this a sneak peek at some of the advances that will be available.

Jump to the Downloads section, and give it a spin right now, or continue reading to learn more about improvements in this release. You can also try the Web editor for this release.

The cover illustration is from Soul Dier - Part 1, a turn-based JRPG where you embark on a story-driven journey in a mysterious, hand-crafted world. You can buy the game or try out the demo on Steam and follow the developers on their website, YouTube, or Discord.

Highlights

Core

Thanks to work particularly by lawnjelly and Lukas Tenbrink, much of core has been heavily optimized, including faster access to ProjectSettings, faster object casting, move semantics, and use of faster data structures benefiting 2D and 3D.

3D physics interpolation

In tandem with work on Godot 4.5, the 3D physics interpolation has been rewritten from the ground up (GH-103685).

This has enabled us to fix a number of longstanding bugs and usability issues (particularly with non-interpolated tree branches), as well as more accurately representing pivot relationships which should give a smoother result.

Luckily we have already worked through a lot of the bugs in 4.5 betas, but let us know if you spot any!

Blob shadows

As an alternative to traditional shadow mapping, Godot 3.7 introduces support for analytical sphere and capsule soft shadows. While this requires some setup of blob shadow caster nodes, the results can look great, and can perform better than shadow mapping in many situations, and are an attractive option especially on mobile.

Blob shadows are typically only used on moving objects (as only a limited number of blobs can be used at one time), and are ideally used in conjunction with lightmaps for static geometry.

See (GH-84804) for full details.

Mutable audio drivers

While most of you will be making games with constant audio, those making applications (as well as users of the Editor itself) can now benefit from experimental “mutable audio” via hotswapping the audio driver (GH-63458). This can dramatically reduce CPU usage. Audio is surprisingly one of the biggest CPU hogs in the Editor, despite it rarely playing any sounds!

This is good news especially for those of you using low-power PCs, or developing on battery-powered devices.

Note that we are expecting regressions on some platforms / systems if hotswapping is not supported, this release is experimental and we are using it to identify problem platforms. You can help us by testing this in the editor, by checking that sound effects play correctly. If you encounter problems playing sounds, please report it on GitHub so we can investigate, and temporarily clear the muting flags in the editor in editor_settings/interface/audio/ until we have it fixed.

Bug fixes and backports

As always, in addition to feature work, there have been a number of bugs fixed, and backports from Godot 4.x. These are detailed in the notes below. Of course the flow is two-way. Godot 4.x has also benefited from a number of new features forward ported from 3.x.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

2D: Make selected tile in TileSet more visible through red outline (GH-105439).
3D: FTI - global_transform_interpolated() on demand for invisible nodes (GH-107307).
3D: Pre-calculate is_visible_in_tree() (GH-107324).
Audio: Add ability to mute AudioServer (GH-63458).
Codestyle: Simplify ObjectDB::get_instance() casting (GH-100603).
Core: Allow constructing Quat from two Vector3s (GH-90464).
Core: Object::call() prevent debug lock accessing dangling pointer (GH-96862).
Core: Add move semantics to core containers (GH-100995).
Core: Add GLOBAL_GET cached macros (GH-103763).
Editor: Cancel tooltips when the mouse leaves the window (GH-95978).
Editor: Improve Class display in Create dialog (GH-105459).
Editor: Add an editor option to copy system info to clipboard (GH-105674).
GDScript: Backport “Cleanup function state connections when destroying instance” for Godot 3 (GH-97464).
GUI: Expose some helper methods on Viewport (GH-92573).
Input: Fix Xbox Controller on Android (GH-106021).
Physics: Fix physics platform behaviour regression (GH-97316).
Plugin: Backport “[Editor] Add EditorPlugin::scene_saved signal” (GH-99857).
Rendering: Implement glow map effect (GH-93133).
Rendering: Physics Interpolation - Move 3D FTI to SceneTree (GH-103685).
Rendering: FTI - Add custom interpolation for wheels (GH-105816).
Rendering: Blob shadows (GH-84804).
VisualScript: Bind Array and Pool*Array get and set functions (GH-96135).

Changelog

44 contributors submitted 130 fixes for this release. See our interactive changelog for the complete list of changes since 3.6-stable.

This release is built from commit a117d512b.

Downloads

Download Godot 3.7 dev1

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript, GDNative, and VisualScript.

.NET build (marked as mono) includes support for C#, as well as GDScript, GDNative, and VisualScript.

Known issues

There are currently no known issues introduced by this release.

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

In particular, any change that would cause a regression in your projects is very important to report (e.g. if something that worked fine in previous 3.x releases, but no longer works in this snapshot).

Support

Donate now

Dev snapshot: Godot 4.6 dev 3

2025-11-04T12:00:00+00:00

Our third development snapshot of the 4.6 release cycle is upon us, and now the floodgates are well and truly open. The enhancements are bigger than ever, with several of them overhauling the look of the editor itself entirely! Big features necessitate big changes, which means the potential for big bugs and regressions; early reports and tests remain crucial to catch these issues as soon as possible.

The cover illustration is from My Card Is Better Than Your Card!, a roguelike deckbuilder where you stick stickers to become the coolest kid on the playground. You can get the game or try the demo on Steam, and follow the developers on YouTube or Bluesky.

Highlights

New editor theme

Longtime users of the Godot Editor are likely familiar with one of its most popular custom themes: the Godot Minimal Theme. Created by passivestar, and showcased in the first dev snapshot, this skin has become a favorite for many users thanks to a focus on its namesake: minimalism. One of the most frequent suggestions from the community has been an official integration of this theme in some capacity, to make the barrier of entry that much shorter. We’ll do you one better: it’s now the default theme for the editor!

Michael Alexsander was tasked with helming the official implementation of this theme (GH-111118), receiving help from passivestar directly to ensure a smooth and streamlined transition. Through his efforts, as well as several accompanying theme-related PRs from many other contributors such as Douglas Leão, we’re excited to (re)-introduce the newly dubbed “Modern Theme”!

We still love our original theme, henceforth known as the “Classic Theme,” and will continue to support it in tandem. It can be accessed through the interface/theme/style and interface/theme/preset settings.

It may surprise some that we chose to set the default color to a dark grey instead of the classic blue that makes our editor stand out at first glance. It is primarily due to the fact that it caused some issues with the perceived white balance. Removing hue from the equation resolves most of these problems.

While originally implemented as a 1-to-1 port of the Minimal Theme, we’ve already been making adjustments to better suit the design philosophies of the Godot Foundation itself. Namely: prioritizing accessibility options and retaining readability. As such, this implementation should not be taken as a final representation of this theme; the team fully welcomes and encourages early feedback in order to flush out any lingering blind spots. Nonetheless, we’re excited with the amount of progress made already, and hope you enjoy this new theme firsthand!

The project showcased in the new theme exhibit is Librerama, by Michael Alexsander.

Condense inspector layout for arrays

In a similar vein to the previous point, we’ve applied a similar minimal-style overhaul to the array inspector. This change is inherent to the inspector itself, so the benefits will be shown regardless of which theme is chosen. Koliur Rahman has brought us this revamped implementation, trimming away wasted space by consolidating information and logic to their essential elements (GH-103257).

Old	New

Rendering: Overhaul screen space reflections

The editor has gotten a lot of love in this blog post, so let’s shake things up with some rendering news! Skyth has been hard at work overhauling our current screen space reflection logic, and their efforts in GH-111210 have resulted in better performance and higher quality! The PR is readily available for those seeking a more technical deep-dive on the “how”, but we’re here to showcase the end results; they should speak for themselves:

64 Max Steps

Old	New (half)	New (full)

256 Max Steps

Old	New (half)	New (full)

Roughness

Old	New

Metallic Surface

Old	New (half)	New (full)

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

Animation: Remove default skeleton path in MeshInstance3D (GH-112267).
- If relying on the default skeleton_path in some scenes, users should manually re-specify the parent node as the NodePath, or they can enable the animation/compatibility/default_parent_skeleton_in_mesh_instance_3d project setting to restore the pre-4.6 behavior.
Editor: Add Create Resource Hotkey (GH-110641).
Editor: Add splitter to “Create New Node” dialog (GH-111017).
Editor: Android Editor: Add game speed control options in game menu bar (GH-111296).
Editor: FindInFiles: Allow replacing individual results (GH-109727).
Editor: Speed up deletion via the Scene Tree Dock in large trees (GH-109511).
Editor: Use Inter as the default editor font, features enabled (GH-111140).
Export: Android: Add export option to use scrcpy to run project from editor (GH-108737).
Export: Fix custom icon in Android export (GH-111688).
Import: Betsy: Convert RGB to RGBA on the GPU for faster compression (GH-110060).
Navigation: Make NavigationServer backend engine selectable (GH-106290).
Rendering: Add Persistent Buffers utilizing UMA (GH-111183).
Rendering: D3D12: Greatly reduce shader conversion time & fix spec constant bitmasking (GH-111762).
Rendering: Implement a very simple SSAO in GLES3 (GH-109447).
Rendering: Overhaul and optimize Glow in the mobile renderer (GH-110077).
Rendering: Use half float precision buffer for 3D when HDR2D is enabled (GH-109971).
Tests: Add Android instrumented tests to the app module (GH-110829).

Changelog

101 contributors submitted 239 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-dev2. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit 9d84f3d13.

Downloads

Download Godot 4.6 dev3

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

There are currently no known issues introduced by this release.

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Donate now

Maintenance release: Godot 3.6.2

2025-10-23T11:00:00+00:00

Edit 2025-10-25 @ 21:30 UTC: The original release had a regression affecting the Windows binaries (at least the editor) which lead to crashes (GH-111979, GH-112021). This was caused by the update to MinGW-GCC 14.2.1 for official build containers. We’ve temporarily reverted that change and rebuilt the Windows binaries today. If you downloaded this release for Windows or the export templates before 2025-10-25 21:30 UTC, please redownload it as the binaries have been replaced.

Although we fixed many of the major 3.6 bugs in Godot 3.6.1 in June, we have decided to make a new 3.6 point release in order to keep up to date with platform requirements.

Google announced that from August 31, 2025 (with possible extension to November 1, 2025), apps and updates submitted to the Play Store must target Android 15 (API level 35) and support 16 KiB page size. As a result we have updated Godot Android APIs and made compatibility changes to ensure users can update their Godot 3 games on Play Store with 3.6.2.

Since we had to rebuild Mono for Android with a 16 KiB page size, we took the opportunity to update our build containers to provide more recent toolchains for official builds. Like for 3.6.1, UWP export templates are no longer provided in this build (but can be compiled from source if needed).

This is a safe and recommended update for all Godot 3.6.x users. It should have no major impact on your projects, even complex ones in production, if you’re already using 3.6.1-stable.

Download Godot 3.6.2 now or try the online version of the Godot editor.

Download Godot 3.6.2 stable

Linux

macOS

Windows

Export templates and other downloads Make a Donation

The illustration picture for this article comes from House of Necrosis, a turn-based horror RPG with retro 32-bit 3D graphics. It is developed by Warkus with Godot 3.6 Mono. You can get the game on Steam, and follow the developer on Bluesky.

Changed

Buildsystem: Update toolchains for official builds (Fedora 42 base, Mono 6.12.0.206, ~~MinGW-GCC 14.2.1,~~ Xcode 16.2) (build-containers#156).
- The update of the Windows toolchains to MinGW-GCC 14.2.1 was temporarily reverted as it introduced crashes with LTO. 3.6.2-stable Windows binaries (editor and export templates) were rebuilt with the previous MinGW-GCC version on 2025-10-25 at 21:30 UTC.
Network: mbedTLS: Update to mbedTLS 3.6.5 (GH-108382, GH-111845).
Porting: Android: Update to target API 35, NDK r28, 16kb page size (GH-108433).
Porting: Android: Address API 35 UI changes (GH-110255).
Porting: Android: Set minsdk to 21, workaround fseeko error in Opus (GH-111061).
Porting: iOS: Switch window creation to UIScene (GH-111103).
Thirdparty: Enable builds with miniupnpc API 18 (GH-100389).

Fixed

Buildsystem: Fix build on macOS 26 by removing AGL framework link (GH-110898).
Editor: Fix inability to assign script after clearing (GH-108171).
Editor: Fix Open Editor Data/Settings Folder menu in self-contained mode (GH-110414).
Export: Fix order of operations for macOS template check (GH-108930).
GUI: Fix Line breaking may not work correctly when using color tags with specific font (GH-109695).
Rendering: Batching: Fix MultiRect casting to wrong type (GH-109111).

Changelog

14 contributors submitted 19 fixes for this release. See our interactive changelog for the complete list of changes since the 3.6.1 release.

This release is built from commit 3cd3caab6.

Bug reports

As a tester, you are encouraged to open bug reports if you experience issues with 3.6.2. Please check first the existing issues on GitHub, using the search function with relevant keywords, to ensure that the bug you experience is not known already.

In particular, any change that would cause a regression in your projects is very important to report (e.g. if something that worked fine in 3.6.1 or earlier 3.x releases no longer works in 3.6.2).

Support

Godot is a non-profit, open source game engine developed by hundreds of contributors on their free time, and a handful of part or full-time developers, hired thanks to donations from the Godot community. A big thankyou to everyone who has contributed their time or financial support to the project!

If you’d like to support the project financially and help us secure our future hires, you can do so with the development fund.

Dev snapshot: Godot 4.6 dev 2

2025-10-20T12:00:00+00:00

With our first dev snapshot out of the way, the 4.6 development cycle is no longer constraining itself to the territory of bugfixes. Many long-awaited features and enhancements are seeing the light of day at long last, as this behemoth of a snapshot boasts over 300 improvements in all! This blog post will aim to highlight the heavy-hitters to the best of its ability, but the sheer number of changes may warrant users to check the interactive changelog for a more thorough dive. With new features comes the potential of new bugs, so early testing and reporting will be essential to catching regressions as quickly as possible.

The cover illustration is from Upload Labs, an idle game where you build and optimize your computer’s system from the ground up. You can get the game for free on Steam, and follow the developers on YouTube or Discord.

Highlights

Build Godot Engine as a library

A very common request we’ve seen regarding Godot is the ability to build the engine as a standalone library. In the past, it’s not something we’ve actively pursued, as the engine paradigm is so central to many of our design philosophies. However, as time has gone on, we’ve encountered more and more scenarios where simply having the ability to access Godot in an isolated context is absolutely necessary for certain workflows. So while a fully-fledged integration of this concept isn’t something we fully support at this time, Gergely Kis has put in the work to allow for a functional baseline (GH-110863). Currently dubbed LibGodot internally, there’s now a basic support for a GodotInstance to function as an entry point for these specialized workflows.

`ObjectDB` profiling tool

Another common request from more technically-minded users has been a proper means of profiling ObjectDB, which can be considered the heart of our entire Object structure. First-time contributor Aleksander Litynski took to this daunting task, bringing us the ObjectDB Profiler tool (GH-97210). With this, users will be able to take snapshots of the current ObjectDB state during debug sessions, and compare that to other snapshots at a given point in time. These snapshots can also be viewed in a variety of contexts detailed in the PR’s original post, but the short version is finding or exporting a diff between states has never been easier or more accessible!

Improved automatic mesh LOD using component pruning

Our mesh simplifier currently supports the ability to collapse edges, but lacked functionality for simplifying the components themselves. Arseny Kapoulkine has addressed this shortcoming, enabling topologically complex sections of a larger mesh to more easily reach the desired LOD target (GH-110028).

Rotation visualization and snapping

The way that we present and handle our 3D space has already seen a fair number of improvements in the 4.6 cycle, but these two warrant particular mention for implementing popular features that are found in many 3D modelling programs today. Firstly, Robert Yevdokimov has expanded the 3D Transform gizmo to visualize the current delta angle of a rotation operation (GH-108576). This process is non-accumulating, meaning rotations beyond 360° are reset.

The second comes to us from passivestar, who integrated orbit snapping to the 3D Viewport (GH-111509). While holding Alt, exiting an orbit pan will cause the resulting view to be snapped to a static, 45° offset. This is similar to directly swapping to an orthographic view, but from the convenience of orbitting and allowing for more granular 45° midpoints.

Rendering: Blend glow before tonemapping and change default to screen

HDR has been growing in prevalence as a feature in modern displays, but actual support of the feature is lagging behind somewhat. This is largely because most existing programs were designed with sRGB in mind, and necessitate retrofitting themselves to handle HDR. This process is much easier said than done, and sometimes the effects can be invisible to the average user, meaning such advancements are rarely given a proper highlight. Allen Pestaluky has broken this convention, with a PR that improves visual quality for all users and sets the stage for HDR output support (GH-110671).

The first change was to blend glow before tonemapping for all rendering methods and blend modes (except soft light). While this was always the case in the Compatibility renderer, the functionality has been expanded to the Mobile and Forward+ renderers as well. Blending beforehand results in the glow effect blending in a more realistic fashion, sidestepping the hard edges and hue shifts if blended after.

Original scene	Before tonemapping (screen, AgX, 16.29 white)	After tonemapping (screen, AgX, 16.29 white)

The second change was adjusting the default blend mode from soft light to screen for all renderers. This too was already the case for the Compatibility renderer, though that default was set with the behavior of blend glow before tonemapping in mind. As such, a change in the other renderers to match the new behavior is to be expected.

Renderer	Soft light blend mode	Screen blend mode
Mobile
Forward+

This change technically breaks compatibility since it will result in a noticeable visual change, and the previous behavior cannot be restored by simply adjusting settings. In most cases we are confident that this change in behavior will be a direct upgrade. But this change is something to be aware of if your game is using Glow at all.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

Core: Add reserve_exact to CowData, and change growth factor to 1.5x (GH-106039).
Core: Add reserve function to Array, Vector, and String (GH-105928).
Core: Add unique Node IDs to support base and instantiated scene refactorings (GH-106837).
Documentation: Drop the experimental label for the Jolt Physics integration (GH-111115).
Editor: Add game speed controls to the embedded game window (GH-107273).
Editor: Add source lines to file locations on POT generation (GH-111419).
Editor: Make file part of errors/warnings clickable in Output panel (GH-108473).
Editor: Rework editor docks (GH-106503).
Editor: Store script states for built-in scripts (GH-93713).
GDScript: Add opt-in GDScript warning for when calling coroutine without await (GH-107936).
GUI: Add pivot_offset_ratio property to Control (GH-70646).
GUI: Add auto-scroll behavior when selecting text outside the visible area in RichTextLabel (GH-104715).
GUI: Visualize MarginContainer margins when selected (GH-111095).
Import: OBJ: Support bump multiplier (normal scale) (GH-110925).
Network: Add Core UNIX domain socket support (GH-107954).
Physics: Add MeshInstance3D primitive conversion options (GH-101521).
Physics: Add MultiMesh physics interpolation for 2D transforms (MultiMeshInstance2D) (GH-107666).
Rendering: Add material debanding for use in Mobile rendering method (GH-109084).
Rendering: Implement motion vectors in compatibility renderer (GH-97151).
Rendering: Make OpenXRCompositionLayer and its children safe for multithreaded rendering (GH-109431).

Changelog

114 contributors submitted 323 fixes for this release. See our interactive changelog for the complete list of changes since 4.6-dev1. You can also review all changes included in 4.6 compared to the previous 4.5 feature release.

This release is built from commit 7864ac801.

Downloads

Download Godot 4.6 dev2

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

The “Replace in Files…” function is currently broken, and will clear the contents of all files with matches when used. This issue will be fixed in the next snapshot via GH-112033.

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Donate now

Maintenance release: Godot 4.5.1

2025-10-15T12:00:00+00:00

We saw the release of Godot 4.5 less than a month ago, and have already been absolutely overwhelmed with the positive reception. Since then, our team has been hard at work on the development phase of Godot 4.6 (and subsequently its first snapshot), and ensuring that any new regressions/bugs reported after the release of 4.5 are dealt with swiftly. The community has done an absolutely fantastic job at helping our team find and squash all of those aforementioned issues, and paved the way for us to deliver 4.5.1-stable for you today!

Maintenance releases are expected to be safe for an upgrade, but we recommend to always make backups, or use a version control system such as Git, to preserve your projects in case of corruption or data loss.

Download Godot 4.5.1 now or try the online version of the Godot editor.

Download Godot 4.5.1 stable

Linux

macOS

Windows

Export templates and other downloads Make a Donation

The illustration picture for this article comes from Starfinder: Afterlight, a party-based RPG set in the science-fantasy universe of Paizo’s Starfinder. You can support the title on Kickstarter and pre-order the game on Steam. You can follow the developers on Bluesky or YouTube.

Changes

50 contributors submitted around 92 fixes for this release. See our interactive changelog for the complete list of changes since the 4.5-stable release.

2D: Fix redundant calls of CanvasItemEditor::_update_lock_and_group_button on SceneTreeEditor node selection (GH-110320).
3D: GridMap: Fix cell scale not applying to the cursor mesh (GH-104510).
Animation: Fix Reset on Save corrupt poses if scene has multiple Skeletons (GH-110506).
Animation: Make extended SkeletonModifiers retrieve interpolated global transform (GH-110987).
Audio: Add one padding frame to QOA buffer for short streams (GH-110515).
Core: Change “reserve called with a capacity smaller than the current size” error message to a verbose message (GH-110826).
Core: Check for NUL characters in string parsing functions (GH-110556).
Core: X11 input: prevent non-printable keys from producing empty strings (GH-110635).
Documentation: Document typed dictionaries and arrays in the class reference (GH-107071).
Editor: Add column boundary check in the autocompletion (GH-110017).
Editor: Fix selection of remote tree using the keyboard (GH-110738).
Editor: Set correct saved history after clearing (GH-111136).
Export: Android: Ensure proper cleanup of the fragment (GH-109764).
Export: Metal: Fix Metal compiler version inspection (GH-110873).
Export: Windows: Fix application manifest in exported projects with modified resources (GH-111316).
GDExtension: Fix --dump-extension-api-with-docs indentation (GH-110557).
GDExtension: Prevent breaking compatibility for unexposed classes that can only be created once (GH-111090).
GDScript: LSP: Fix repeated restart attempts (GH-111290).
GUI: Editor font: do not embolden the Main Font if it’s variable (GH-110737).
GUI: Enforce zero width spaces and joiners with missing font. Do not warn about missing non-visual characters (GH-111355).
GUI: Fix bottom panel being unintentionally draggable (GH-111121).
GUI: Fix text servers build with disabled FreeType (GH-111001).
GUI: TextServer: Enforce zero width spaces and joiners to actually be zero width and not fallback to regular space (GH-111014).
Import: Material Conversion Error Handling (GH-109369).
Import: OBJ importer: Support bump multiplier (normal scale) (GH-110925).
Input: Fix invalid reported joypad presses (GH-111192).
Input: Fix weak and strong joypad vibration being swapped (GH-111191).
Navigation: [Navigation 2D] Fix sign of cross product (GH-110815).
Navigation: Make navmesh rasterization errors more lenient (GH-110841).
Physics: Fix bug in ManifoldBetweenTwoFaces (GH-110507).
Physics: Fix CCD bodies adding multiple contact manifolds when using Jolt (GH-110914).
Physics: Fix crash when calling move_and_collide with a null jolt_body (GH-110964).
Physics: JoltPhysics: Fix Generic6DOFJoint3D not respecting angular limits (GH-111087).
Porting: Change macos.permission.RECORD_SCREEN version check from 10.15 to 11.0 (GH-110936).
Porting: macOS: Always use “Regular” activation policy for GUI, and headless main loop for command line only tools (GH-109795).
Porting: Unix: Fix retrieval of PID exit code (GH-111058).
Porting: Wayland: Emulate frame event for old wl_seat versions (GH-105587).
Porting: Workaround X11 crash issue (GH-106798).
Rendering: Compatibility: Fix backface culling gets ignored when double-sided shadows are used (GH-109793).
Rendering: DirectX DescriptorsHeap pooling on CPU (GH-106809).
Rendering: Disable unsupported SSR, SSS, DoF on transparent viewports (GH-108206).
Rendering: Divide screen texture by luminance multiplier in compatibility (GH-110004).
Rendering: Fix D3D12 stencil buffer not clearing (GH-111032).
Rendering: Fix glow intensity not showing in compatibility renderer (GH-110843).
Rendering: Fix LightmapGI not being correctly applied to objects (GH-111125).
Rendering: Fix OpenXR with D3D12 using the wrong clip space projection matrix (GH-110865).
Rendering: Increase precision of SpotLight attenuation calculation to avoid driver bug on Intel devices (GH-110363).
Rendering: Move check for sky cubemap array back into the SkyRD initializer (GH-110627).
Rendering: OpenXR: Fix ViewportTextures not displaying correct texture (OpenGL) (GH-110002).
Rendering: Sort render list correctly in RD renderers (GH-111054).
Rendering: Windows: Try reading GPU driver information directly from registry (GH-109346).
XR: Fix late destruction access violation with OpenXRAPIExtension object (GH-110868).

Known incompatibilities

As of now, there are no known incompatibilities with the previous Godot 4.5 release. We encourage all users to upgrade to 4.5.1.

If you experience any unexpected behavior change in your projects after upgrading to 4.5.1, please file an issue on GitHub.

Bug reports

Support

If you’d like to support the project financially and help us secure our future hires, you can do so using the Godot Development Fund.

Donate now

Godot Showcase - Material Maker

2025-10-14T14:00:00+00:00

Today, we want to showcase Material Maker, which is an open-source application made with Godot. Material Maker is designed to create materials and textures for use in physically-based rendering (PBR). As a reminder, Godot is more than just a game engine; using its UI building blocks, it is possible to create full-featured applications for desktop, mobile and web platforms. In fact, the Godot editor is made with Godot itself!

Material Maker had its 1.4 release in early October. This marks a significant milestone in the project, as this is the first version to be running on Godot 4. We interviewed its author, RodZilla, about how this project came to fruition and what its future might look like.

Can you tell us a little bit about yourself and your project?

Hello, I’m Rodolphe Suescun, also known as RodZilla. I am 53, I live in Grenoble, France, and work as a senior software developer in the microelectronics industry, mostly on electronic design automation tools and embedded software.

I’ve been into game development as a hobby for 25 years, mostly learning, experimenting, and creating prototypes.

I started Material Maker back in 2018 because I wanted to create 3D games but was not very good at drawing textures. I put the project on GitHub and itch.io without much of a plan, and didn’t really communicate about it. Then one day, GameFromScratch made a video about my project, downloads started rising, and a community began forming, first on Reddit, then later on Discord.

When Material Maker reached 10,000 downloads, GameFromScratch encouraged me to apply for an Epic MegaGrant, which allowed me to spend a bit more time developing the project for a few months.

Although it is perceived as a procedural texture authoring tool, Material Maker is mainly about generating shaders which is why it has a few uncommon features, such as exporting shaders for Shadertoy, or animated or even raymarching materials for game engines. This is also what makes it so much fun to develop.

Material Maker now has almost 250 nodes and can export to Godot, Unity, and Unreal. It is also possible to create new nodes (either by assembling existing nodes or by writing their code using Godot shading language) and new export targets.

Another key part of the project is the website, where artists can share the amazing materials and nodes they create. It is the best showcase of what the tool can do, and a nice source of examples for new users.

Finally, I’m no longer alone and Material Maker has a few active contributors such as williamchange, Jowan-Spooner, and NotArme who helped a lot on the 1.4 release.

Can you give us some examples of games developed with the help of Material Maker?

The first two games that come to mind are Crown Gambit and Zefyr: A Thief’s Melody, which were both released on Steam in June.

Crown Gambit is a narrative dark fantasy deck-building game (made with Godot!). Rachel Dufossé, who worked as a 2D/3D artist on the project, joined our Discord server two years ago, asking questions and showing her work from time to time, while actively promoting Material Maker in the studio she works for, Wild Wits Games. She ended up giving a talk about her work with Material Maker to Atlangames, the network of video game companies in her region.

Zefyr: A Thief’s Melody is an action-adventure game with nice Wind Waker and Beyond Good and Evil vibes. Mathias Fontmarty, the solo developer of this project, did not interact as much with the community, but gave a few talks about Material Maker at conferences (such as Capitole du Libre in Toulouse).

Those are beautiful projects, and it is always a real pleasure to see users carry the Material Maker flag in their own way, whether by creating amazing games or by sharing their experiences.

I can mention a few others, released or soon-to-come, such as Chrono Weaver, Beyond the Space Wall, Blocky Ball, Polylithic, KOOK, and Neverlooted Dungeon.

Note to readers: the 1.4 release has a new splash screen that shows games, shaders, and materials created with Material Maker, so please feel free to contact me on Discord if you used it for your game.

One of Material Maker’s many splash screens; some of them are even animated!

What were some of the biggest challenges you faced during the development process, and how did you overcome them?

At the very beginning of the project, nodes were nearly hardcoded in GDScript and I soon realized it was a huge mistake. So I had to take a step back and come up with a generic way of describing the shader code used by nodes and assembling them. Then I added an editor for those shader nodes, which made node creation really easy.

I am not sure it was that big of a challenge, but it took a few weeks of not touching the code, and thinking about use cases and code generation to come up with the right solution. Although shader code generation has been improved and extended since then, it has not changed that much.

Exporting to other game engines was a bit challenging. I had to understand how they handle materials and come up with a convenient export workflow. Unreal needs a material graph and I didn’t find an easy-to-generate file format for it, so Material Maker generates a Python script that creates the graph when executed in Unreal (I know it is an ugly solution).

This challenge is not completely solved, though. When exporting dynamic materials to Unreal and Unity, Material Maker “translates” the generated GLSL shader code to HLSL. This part will need to be rewritten at some point, based on a proper GLSL parser.

Of course, there is optimization, mainly to decrease rendering time for generated textures. And there is still a lot more to be done.

On the non-technical challenges side, I would say that evolving from a “lone wolf working on personal projects” mindset to interacting with a very nice community of users and contributors was not without glitches. But I guess it was a well-needed evolution.

The project is under the MIT license and available for everyone at GitHub. What made you decide to make the project free and open source?

I have been an open-source software user (and advocate) for quite some time. I think I installed Linux for the first time back in 1993. If I remember correctly, that was about 30 floppy disks.

When I started Material Maker, it was just an experiment I intended to use to create textures, so I shared it under the MIT license, just like all prototypes you can find on my GitHub.

And for me it is a hobby anyway, so it was never meant to be paid software.

That said, donations pay for the domain name, the VPS, the “Apple tax”, and whatever hardware I needed to develop Material Maker and port it to all supported platforms, and I’m pretty happy with that. Huge thanks to everyone who supports this project!

Material showcased: Beehive by RodZilla (included in the examples/ folder with Material Maker)

How did you discover Godot? What made you pick it for your project?

It is really funny that I discovered Godot just like Material Maker gained its current visibility. I discovered this game engine while watching a video from GameFromScratch covering Godot around the time it went open-source.

I tried it for a few very small game prototypes (including one featuring a silly mouse for my very first game jam) and I must admit it immediately clicked for me. Godot was far from what it would become, but I already loved the nodes approach and how natural the overall design felt.

I’ve been using Godot for all my game development projects and prototypes ever since, and it consistently proves easy and efficient to work with.

Material Maker 1.4 is the first version to be running on Godot 4. What upgrades does Godot 4 bring to your project?

The main change that Godot 4 brings is compute shaders which give a lot more flexibility for shader generation and help improve performance. I also used them to introduce new generated meshes (rounded cube and cylinder) to replace the default ones.

Support for multiple windows made it possible for me to add flexible layout with undockable panels, and I will probably expose this part as a Godot addon so other application developers can reuse it.

I also started using the new GDScript features (mainly typed arrays and dictionaries), but it will take a long time before all of Material Maker’s code is updated.

Material showcased: Pavement Generator by Tarox

What challenges have you encountered while upgrading the project to Godot 4? What would you like to see implemented?

The main challenge for me was learning the new RenderingServer and RenderingDevice and finding out how to best use compute shaders for Material Maker’s use cases. Also, API changes between releases have been a bit annoying, but that’s the price to pay when using bleeding edge releases.

The only thing I’m missing for Material Maker is support for saving EXR files in the release templates. I currently have to use custom-built templates for Material Maker. This is not much of an annoyance since I only have to recompile Godot whenever I use a new release.

But speaking of possible improvements for Godot, while doing game jams with my team, we noticed Godot makes it hard for audio designers to do their job without diving into the whole Godot project (since sounds are triggered wherever there is an AudioStreamPlayer node). I wrote a small addon (called TRAudio and available on my GitHub) that tries to bridge the gap between the audio designer and the software developer, but I think Godot would benefit from supporting this natively. The addon is OK in most use cases, but triggering sounds in animations is not as convenient as it could be.

Do you have any new features or improvements in mind for Material Maker in the future?

Of course, Material Maker has a roadmap, but I generally do not communicate much about it so I do not promise anything my limited free time does not allow.

That said, Material Maker 1.0 (and all previous releases) were about delivering a nice toolkit for creating seamlessly tileable materials. And 2.0 will focus on texturing 3D models (and 1.4 is a step in that direction with the new Mesh Map node).

The painting tool in Material Maker is a nice prototype and can do quite a few impressive things (brushes are completely procedural and described by connecting nodes), and in 1.4, all PBR channels can be painted by a single compute shader. But it becomes way too slow with complex brushes, and the end result of each stroke is stored in the final textures of the painted layer. So we start with a procedural brush, and lose the procedural aspect while painting (which defeats the purpose of the approach).

So instead of improving the current painting tool, I’m thinking of introducing very basic painting features in the material authoring tool. By “very basic”, I mean painting simple masks that can be applied to parts of the graph, or UV maps that will help place a procedural shape or pattern using a CustomUV node. Thus painting would become a guide for procedural generation, which would allow an interactive yet nearly non-destructive workflow for texturing models.

And in the short term, the EasySDF node and its corresponding dialog (that is used to edit 2D and 3D Signed Distance Functions) will get an update, on both UI and code generation sides.

Material showcased: Broken Floor by Tarox

How can one learn to use Material Maker?

This is probably the weakest point of this project. There are nice video tutorials made by Kasper Arnklit Frandsen and a few more advanced ones by Pavel Oliva, but they are a bit old. It is also possible to follow Substance Designer tutorials; the nodes are different, but the concepts are the same.

Another great way to learn is to grab materials from the website and study their graph.

In any case, you probably want to join our Discord server. Material Maker has a very nice and welcoming community.

Material Maker definitely needs a few good-quality “official” video tutorials and I really need to make sure they happen.

Although I mainly mentioned Material Maker, I recently participated in six Godot Wild Jams, followed by a Godot XR Game Jam, with a truly awesome team (now named Cularo Games). We’re now planning to push one of those projects further. The lone wolf in me will soon be gone for good.

Thank you RodZilla for taking the time to answer our questions! We look forward to the future of Material Maker.

Material Maker is free and open-source. It can be downloaded for Windows, macOS, and Linux on itch.io. Along with the GitHub repository, there is also a subreddit and Discord server you can join to interact with its community.

Release candidate: Godot 4.5.1 RC 2

2025-10-08T12:00:00+00:00

Last week saw our first Release Candidate snapshot for 4.5.1, and in that time there have been even more critical bugfixes suitable for backporting. As such, we’re doing one more pass for good measure: 4.5.1-rc2 has arrived! Our top priority is ensuring the hotfix release is as stable as possible, so be sure to test and report any issues that aren’t present in 4.5-stable.

The illustration picture for this article comes from Trainatic, a cozy(?) game where you guide your train through a procedurally-generated world, unlocking powerful synergies and skilltrees to aid your unyielding destruction. You can buy the game on Steam, and follow the developer on Bluesky or YouTube.

What’s new

31 contributors submitted 45 improvements for this release. See our interactive changelog for the complete list of changes since the 4.5.1-rc1 release. You can also review all changes included in 4.5.1 compared to the previous 4.5 feature release.

2D: Fix redundant calls of CanvasItemEditor::_update_lock_and_group_button on SceneTreeEditor node selection (GH-110320).
3D: GridMap: Fix cell scale not applying to the cursor mesh (GH-104510).
Animation: Fix backward/pingpong root motion in AnimationTree (GH-110982).
Animation: Fix Reset on Save corrupt poses if scene has multiple Skeletons (GH-110506).
Animation: Make extended SkeletonModifiers retrieve interpolated global transform (GH-110987).
Core: Change “reserve called with a capacity smaller than the current size” error message to a verbose message (GH-110826).
Documentation: Fix and improve Node2D.move_local_{x,y}() description (GH-110878).
Editor: Add column boundary check in the autocompletion (GH-110017).
Editor: Fix DPITexture editor icon name (GH-110661).
Editor: Fix Quick Open history (GH-111068).
Editor: Fix selection of remote tree using the keyboard (GH-110738).
Editor: Fix the project file was not updated when some files were removed (GH-110576).
Editor: Set correct saved history after clearing (GH-111136).
Editor: Tweak macOS notarization export message in the editor (GH-110793).
Export: Windows: Fix application manifest in exported projects with modified resources (GH-111316).
GDExtension: Prevent breaking compatibility for unexposed classes that can only be created once (GH-111090).
GDScript: LSP: Fix repeated restart attempts (GH-111290).
GUI: Editor font: do not embolden the Main Font if it’s variable (GH-110737).
GUI: Enforce zero width spaces and joiners with missing font. Do not warn about missing non-visual characters (GH-111355).
GUI: Fix bottom panel being unintentionally draggable (GH-111121).
GUI: Fix LineEdit’s placeholder text being selected when double clicking (GH-110886).
GUI: Fix text servers build with disabled FreeType (GH-111001).
GUI: TextServer: Enforce zero width spaces and joiners to actually be zero width and not fallback to regular space (GH-111014).
Import: OBJ importer: Support bump multiplier (normal scale) (GH-110925).
Input: Fix invalid reported joypad presses (GH-111192).
Input: Fix weak and strong joypad vibration being swapped (GH-111191).
Physics: Fix crash when calling move_and_collide with a null jolt_body (GH-110964).
Physics: JoltPhysics: Fix Generic6DOFJoint3D not respecting angular limits (GH-111087).
Porting: Change macos.permission.RECORD_SCREEN version check from 10.15 to 11.0 (GH-110936).
Porting: macOS: Always use “Regular” activation policy for GUI, and headless main loop for command line only tools (GH-109795).
Porting: Unix: Fix retrieval of PID exit code (GH-111058).
Porting: Wayland: Emulate frame event for old wl_seat versions (GH-105587).
Porting: Wayland: Inhibit idle in DisplayServerWayland::screen_set_keep_on (GH-110875).
Rendering: Divide screen texture by luminance multiplier in compatibility (GH-110004).
Rendering: Fix glow intensity not showing in compatibility renderer (GH-110843).
Rendering: Fix LightmapGI not being correctly applied to objects (GH-111125).

This release is built from commit 69796bf7d.

Downloads

Download Godot 4.5.1 rc2

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

During the Release Candidate stage, we focus exclusively on solving showstopping regressions (i.e. something that worked in a previous release is now broken, without workaround). You can have a look at our current list of regressions and significant issues which we aim to address before releasing 4.5.1. This list is dynamic and will be updated if we discover new showstopping issues after more users start testing the RC snapshots.

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

If you’d like to support the project financially and help us secure our future hires, you can do so using the Godot Development Fund.

Donate now

Release candidate: Godot 4.5.1 RC 1

2025-10-02T12:00:00+00:00

It’s been just over two weeks since the release of Godot 4.5, and the overwhelmingly positive community response has been an absolute treat to behold! Our hard-working contributors have taken this energy to kick-start the development phase of Godot 4.6, resulting in our first snapshot coming out earlier this week.

In saying that, the main focus was always going to be hammering out newly reported regressions encountered in the 4.5 release, and integrating any fixes deemed too risky to merge at the time. As such, we’ve already prepared a healthy number of regression fixes for a 4.5.1 maintenance release. This release candidate is intended to validate the fixes in an environment isolated from the new enhancements and features that 4.6 is already boasting. Your testing is crucial to detect and squash any new issues that weren’t present in 4.5-stable, in order to ensure that this hotfix is as clean of an upgrade as possible.

The illustration picture for this article comes from Coal LLC, a capitalism simulator where you fulfill increasingly absurd quotas through increasingly dubious methods. You can buy the game or try out the demo on Steam, and follow the developers on their website.

What’s new

31 contributors submitted 33 improvements for this release. See our interactive changelog for the complete list of changes since the 4.5-stable release.

Audio: Add one padding frame to QOA buffer for short streams (GH-110515).
Buildsystem: Windows: Migrate godot.manifest to platform/windows, include as dependency (GH-110897).
Core: Avoid repeated _copy_on_write() calls in Array::resize() (GH-110535).
Core: Check for NUL characters in string parsing functions (GH-110556).
Core: X11 input: prevent non-printable keys from producing empty strings (GH-110635).
Documentation: Clarify that velocity doesn’t need delta multiplication in CharacterBody documentation (GH-109925).
Documentation: Document the interaction between Light3D cull mask and GI/volumetric fog (GH-110423).
Documentation: Document typed dictionaries and arrays in the class reference (GH-107071).
Documentation: Fix Basis.determinant() doc: uniform scale determinant is scale^3 (GH-110424).
Editor: Correct the order of Diagonal Mode in Add Property (GH-109214).
Editor: Fix typos in BlendSpace2D editor’s axis labels’ accessibility names (GH-109847).
Export: Android: Ensure proper cleanup of the fragment (GH-109764).
Export: Metal: Fix Metal compiler version inspection (GH-110873).
GDExtension: Fix --dump-extension-api-with-docs indentation (GH-110557).
GUI: Fix LineEdit icon positon in right-to-left layout (GH-109363).
Import: Material Conversion Error Handling (GH-109369).
Navigation: [Navigation 2D] Fix sign of cross product (GH-110815).
Navigation: Make navmesh rasterization errors more lenient (GH-110841).
Physics: Fix bug in ManifoldBetweenTwoFaces (GH-110507).
Physics: Fix CCD bodies adding multiple contact manifolds when using Jolt (GH-110914).
Porting: Workaround X11 crash issue (GH-106798).
Rendering: Compatibility: Fix backface culling gets ignored when double-sided shadows are used (GH-109793).
Rendering: DirectX DescriptorsHeap pooling on CPU (GH-106809).
Rendering: Disable unsupported SSR, SSS, DoF on transparent viewports (GH-108206).
Rendering: Fix d3d12 stencil buffer not clearing (GH-111032).
Rendering: Fix OpenXR with D3D12 using the wrong clip space projection matrix (GH-110865).
Rendering: Increase precision of SpotLight attenuation calculation to avoid driver bug on Intel devices (GH-110363).
Rendering: Move check for sky cubemap array back into the SkyRD initializer (GH-110627).
Rendering: OpenXR: Fix ViewportTextures not displaying correct texture (OpenGL) (GH-110002).
Rendering: Sort render list correctly in RD renderers (GH-111054).
Rendering: Windows: Try reading GPU driver information directly from registry (GH-109346).
XR: Fix late destruction access violation with OpenXRAPIExtension object (GH-110868).

This release is built from commit c834443ef.

Downloads

Download Godot 4.5.1 rc1

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

If you’d like to support the project financially and help us secure our future hires, you can do so using the Godot Development Fund.

Donate now

Looking back at GodotCon US 2025

2025-10-01T14:00:00+00:00

As you might know, this year we hosted our first US-based GodotCon in Boston. Taking place at the tail end of spring, this was three solid days focused solely on making games with the Godot Engine. Our first day had hands-on workshops followed by two days of talks. For our inaugural event we had:

Over 300 attendees.
Over 100 proposals.
38 talks.
14 showcases.
3 great days.

GodotCon was run by members of the Boston Godot User Group and Boston Game Dev in co-ordination with the Godot Foundation during Boston Gamedev Week. From May 5th to May 7th we had three days of Godot-focused content at the Microsoft New England Research and Development Center (NERD Center!). A huge thanks to Microsoft for generously donating the space. This would not have been possible without them and their commitment to supporting non-profits and open-source software.

And while we’re at it, a huge thanks to all of our sponsors: Arm Technology, Endless Foundation, W4 Games, Mike Klubnika, Xogot, Binary Solo, and Disla Media. Without them a conference like this would not be possible.

The format

For our first US-based GodotCon, we committed to three days of programming. The first day we had five different workshops that covered a host of interesting topics. Travis Hunter walked folks through their first multiplayer experience with an incredibly fun grand finale where everyone got to play their game together. Scott Doxey showed us how to make a gdextension, end-to-end. Simon taught us way more than we ever needed to know about how Markov Chains work and how we can apply that to our projects. Jesse (CoderNunk) gave us a method for doing anime-style 3D characters using Blender. Nicholas O’Brien went into incredible depth on narrative design.

On days 2 and 3, we got an amazing batch of talks and updates. You may have heard Adam talk about how the team got C# web exports working. Acerola took us super in-depth with Compositor Effects. We got a inside look at converting Domekeeper to multiplayer. And some dufus even talked about making games on your phone. All in all, there was a wide berth of topics from folks from the entire Godot community.

We’re happy to say that we have finally released all of the videos from GodotCon for free on YouTube; everything from lightning talks to workshops!

🔗 Watch them all here

The showcase

In addition to the talks and workshops, we were able to put on a small games showcase.

In no particular order:

Burrito Bear by SpaceOrca: Eat burritos, avoid garbage in three bold, beautiful, shiny dimensions.
Turnip Boy Steals the Mail by Snoozy Kanoo: A free new Turnip Boy adventure.
Memori by PracticalNPC: A precision pixel platformer with challenging puzzles.
Dunderbeck by RUST LTD: Fight, build, and eat your way across the mythical land of Cincinatti.
no signal by exodrifter: An emotional point-and-click hard sci-fi adventure.
Dante’s 9 by John D: A roguelite action-platformer fused with a deckbuilder.
Dukkido by MariSuCho: A physics-based action-RTS, featuring large handcrafted levels and dungeons.
Neongarten by Moonroof Studios: A minimalist cyberpunk city builder.
TurnTide Tales by Comfy Mitten: An epic swashbuckling adventure across the high seas with a daring crew.

We also had some other cool stuff on display!

Xogot: The Godot editor on an iPad native interface.
Sweet Spot: An interactive art exhibit by Michael Berthaud.
Godot Beyond Games: Migeran showed their AR / VR / XR / Mobile / Web / Robotics uses of Godot Engine for non-game work.
Endless Access: An education platform with lots of neat Godot integrations.

Many thanks go to our small group of volunteers who helped everything run smoothly. Volunteers who did tons of design work. Volunteers who helped talks run smoothly. Volunteers who basically lived at the badge and merch tables and helped us pack our awesome swag bags.

(Speaking of swag bags, how cool was our awesome Anthology “cassette” that included games, demos, and experiments by our speakers and showcasers!?)

The future

When we first mentioned GodotCon Boston, folks were disappointed at the thought of missing a Godot event in Europe. Well, let that thought drift away. Although the name might be different, we’ve got Europe’s Godot Engine event, GodotFest happening in November, and the Godot Foundation has already started organizing the GodotCon EU 2026. Get your tickets for GodotFest now! The prices were just lowered, but they go up starting in October.

But what about GodotCon in the US!?

You’re hearing it here first. GodotCon US will take place in Boston again next year. Putting on GodotCon to this level takes a large effort. The Boston Godot User Group put on a well-organized event. This time they have an entire year to prepare for something even bigger and better.

Do you want to put on the next GodotCon in your city? Let’s make it happen! Reach out and get a conversation started. GodotCon loves to travel, but there are a few things we’d prefer to see from a potential GodotCon site:

An experienced, dedicated game development group. It’s hard to trust a group that hasn’t been around for a year to stick together for another. (Besides, you need a large pool of volunteers!)
Some organizing experience.
Somewhere easy to travel to.

Our GodotCon organizers would love to work with you and get you to successfully host an event.

The support

If you’d like to help keep GodotCon running, please consider supporting the Godot Foundation. Our goal for these events is always to try and keep the cost low so that more of the community can participate. Financial support from the Godot Foundation and sponsorships helps us to do so.

Dev snapshot: Godot 4.6 dev 1

2025-09-30T12:00:00+00:00

The first development snapshot for 4.6 has arrived! As is often the case for our first development snapshot, a significant portion of quality PRs from our backlog are finally able to see the light of day, as they were either locked out from the 4.5 feature freeze or deemed too risky to merge for the stable release. In saying that though, this is by far the biggest our backlog has ever been, so getting it all in for an initial snapshot was unrealistic. As such, while this may mean a slower trickle of PRs initially, you can expect future development snapshots to further expand on the foundation that this release sets.

The overwhelming majority of changes this time around are bugfixes, with most already slated to be backported to 4.5.1-stable in the very near future! In a sense, this release is serving not only as a foundation for 4.6, but for 4.5.1 as well; meaning, testing this build is crucial to ensure a smooth release for both. However, we’ve already got quite a few enhancements and features integrated that will remain exclusive to 4.6, so those wishing to stick with 4.5 may want to hold out for 4.5.1-rc1 coming later this week.

As usual, safety precautions should be taken with any pre-release environment. While we prepare these snapshots with the intent to be suitable for general testing, there will always be a non-zero risk of data loss/corruption. Creating backups before hand and/or utilizing version control are strongly recommended!

The cover illustration is from RAM: Random Access Mayhem, a rougelike where you play as the enemies. You can buy the game or try out the demo on Steam, and follow the developers on Twitter or YouTube.

Highlights

Drag-and-drop `@export` variables

Part of starting out slow with enhancements in the development cycle means that you can expect quite a lot of QOL additions in the near future. One such addition that we’re excited to showcase comes from fkeyz: the ability to drag-and-drop objects to the script editor to automatically create an exported variable! (GH-106341)

OpenXR: Add support for Spatial Entities Extensions

As Bastiaan Olij notes in his PR GH-107391, the OpenXR Spatial Entities Extensions was introduced to standardize obtaining and interacting with information about the user’s real world environment. This is an absolute goliath of a specification, and is reflected in the implementation seeing over 75 hundred lines of code changed. If you’re interested in seeing the changes firsthand (and have the necessary equipment for it), be sure to check out Bastiaan’s accompanying demo project.

Hide `Control` focus when given via mouse input

Courtesy of Michael Alexsander, the focus state logic for mouse and touch is now decoupled from keyboard and joypad (GH-110250). While it’s common for programs to have significant overlap between registering inputs of these types, it’s not uncommon for systems to deliberately stylize the two types separately, often handling their inputs in entirely separate ways. This change enables that granular control for toolmakers and UI designers. Included in the PR is a comprehensive ruleset for when focus is shown, which we’ve included below:

Situation
Clicking a `Control` with the mouse, giving it focus.	❌
Successfully switching focus via keyboard/joypad actions.	✔️
Attempting to switch focus via keyboard/joypad actions but still remaining on the same `Control`.	✔️
Clicking somewhere with the mouse while having a `Control` with visible focus.	❌
Clicking with the mouse a visibly focused `Control` (deviates from how it works in browsers).	❌
Using `Control.grab_focus(true)`.	❌

The previous behavior can be achieved by enabling gui/common/always_show_focus_state.

Remove prompt to restart editor after changing custom theme

A common pain-point we’ve heard from creators attempting to integrate custom themes for the Godot editor itself is how pace-breaking the process can feel. This was a direct result of swapping between themes requiring a hard reset of the entire editor instance, making incremental tests tedious and realtime comparison virtually impossible. This makes sense, of course, as an editor’s theme is surely baked into the editor itself such that any change of the sort would need to jump through countless hurdles to make this feature possible. After all, you can’t just flip a switch and have everything “just work”.

Anyway, Robert Yevdokimov flipped a switch and everything “just worked”. (GH-100876)

Oops.

To clarify: once-upon-a-time this reset was almost certainly necessary. Our internal logic for theming and customization is unrecognizable compared to their humble beginnings, and this is far from the first setting that was elevated to real-time support. It’s common for settings that become real-time to have a PR that explicitly targets the feature in question, but it’s rare for such features to have their changes exist in a vacuum. Perhaps there are other features out there, just like this, that have pre-conceived restrictions long-addressed without anyone realizing it. Until someone shows up to challenge those restrictions, we may never know.

The theme showcased for comparison is the Godot Minimal Theme by passivestar.

And more!

There are too many exciting changes to list them all here, but here’s a curated selection:

2D: Avoid unnecessary updates in TileMapLayer (GH-109243).
3D: Do not require editor restart when changing manipulator gizmo opacity setting (GH-108549).
C#: Add C# translation parser support (GH-99195).
Core: Add ‘Find Sequence’ to Spans, and consolidate negative indexing behavior (GH-104332).
Editor: Allow to use sliders for integers in EditorSpinSlider (GH-110459).
Editor: FindInFiles: Show the number of matches for each file (GH-110770).
Editor: Fix vertical alignment of Inspector category titles (GH-110303).
Editor: Show “No Translations Configured” message for empty translation preview menu (GH-107649).
Editor: Speed up large selections in the editor (GH-109515).
Editor: Use a fixed-width font for the expression evaluator (GH-109166).
Export: Add “Show Encryption Key” toggle (GH-106146).
GDScript: Elide unnecessary copies in CONSTRUCT_TYPED_* opcodes (GH-110717).
Import: Switch LOD generation to use iterative simplification (GH-110027).
Porting: Wayland: Implement the xdg-toplevel-icon-v1 protocol (GH-107096).
Rendering: Add methods to draw ellipses (GH-85080).
Rendering: Add ubershader support to material and SDF variants in Forward+ (GH-109401).

Changelog

98 contributors submitted 220 fixes for this release. See our interactive changelog for the complete list of changes since the 4.5-stable.

This release is built from commit 8d8041bd4.

Downloads

Download Godot 4.6 dev1

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

There are currently no known issues introduced by this release.

With every release we accept that there are going to be various issues, which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Donate now

Ensuring quality in the Godot documentation, a continuous process

2025-09-18T14:00:00+00:00

What makes up the quality and usability of an open-source project is not just about its code. A big part of what makes a project useful to the community is its documentation.

Over the years, Godot contributors have developed many tools and processes to ensure the highest possible level of quality for the documentation. Read on if you’re curious about how the documentation is made.

Documentation repository organization

Godot’s documentation is hosted on Read the Docs. This service provides hosting for projects using Sphinx, which is a static site generator targeted at building documentation.

The documentation’s source files are hosted on GitHub. Several customizations have been made to improve readability, such as adding a dark theme (used according to browser/OS preferences) and GDScript syntax highlighting.

There is a continuous integration system in place, which performs several automated tasks:

General continuous integration
- Runs pre-commit hooks and builds the website to ensure no errors occur. The pre-commit hooks are configured to check for typos using codespell.
Synchronize the class reference
- Automatically synchronizes the generated class reference with the class reference XML from the main Godot repository.
Build offline documentation in HTML and ePub formats
- Creates downloads of the documentation in offline-friendly formats.
Check URLs for dead links
- URLs can stop working over time for several reasons. This check makes it possible to be informed of link rot and replace links with archived versions when needed.
Automatically cherry-pick relevant pull requests to stable branches
- The documentation is split into several branches (one for master, one for the latest stable version, one for 4.3 and so on). Pull requests that make changes relevant for stable versions are assigned a label such as cherrypick:4.3. When the pull request is merged, the commit is automatically cherry-picked to the corresponding stable branch.

Internationalizing the documentation

As the Godot community is worldwide, we want the ability to provide not only the Godot editor in users’ native languages, but also the documentation.

To internationalize content that gets continuously updated, we use dedicated tooling to keep the translations in sync with the source material. Sphinx can extract content from each page to put in translation catalogs in the Gettext format (POT/PO files, also supported by Godot!). We merge these 500 POT files into a monolithic “Godot Documentation” component (500,000 words).

The class reference is handled separately as its source material is not Sphinx’s reStructuredText files, but XML files in the engine repository. For this, we use a script to extract the descriptions from the XML files and generate a Gettext POT file (600,000 words).

So we’re currently at 1,100,000 words of documentation to translate! To put this into perspective, the Godot editor’s translation has a bit more than 40,000 words.

Godot uses Hosted Weblate as a collaborative translation platform. This greatly simplifies the barrier to entry for editing Gettext files without merge conflicts, and provides a number of additional features such as suggestions, translation memory, or the ability to cross-compare translations.

Godot Documentation and Class Reference components on Hosted Weblate
Localized documentation websites: cs, de, es, fr, it, ja, ko, pl, pt-br, ru, uk, zh-cn, zh-tw
Documentation on contributing translations
#translation channel on the Godot Contributors Chat

Splitting the contributor documentation to its own website

Since September 2025, documentation for new and returning engine contributors has been split to its own website, contributing.godotengine.org. This website is powered by Sphinx, just like the main documentation. This split was motivated by several factors:

The documentation is split by minor version, but the contributing documentation generally does not need a version split. Feature development always happens on the master branch, with cherry-picking towards the previous stable branch. In practice, it’s easier to maintain only one version of the documentation.
Contributing to the engine requires English reading comprehension. The existing documentation had some translations available, but they were not always complete or up-to-date. Focusing on English for contribution guides reduces the burden on translators, which can then better focus on other sections of the manual.

Note that some of the pages that were previously in the Contributing section of the documentation were moved to a new section called Engine details. These pages are not just useful for engine contributors, but also for people looking to compile their own builds and write custom modules in C++.

As an aside, splitting this website allows it to build much faster, which is useful when testing changes locally. The main documentation website now also builds slightly faster, but is still slow due to containing the class reference. The GitHub repository for the new website can be found at godotengine/godot-contributing-docs.

Class reference progress tracker

The Godot documentation is more than just a manual. It also contains an hosted mirror of the class reference, which documents every class that’s exposed to the scripting API in the engine. This class reference can be read directly offline in the editor, but the hosted version can be linked to on a website.

Since the class reference represents a massive amount of items to document, we built a website to track the documentation progress for each class:

Godot class reference status

This website relies on the doc_status.py script from the main Godot repository, which detects the completion percentage and outputs a Markdown table with the results.

Being aware of the overall and per-class completion percentages at all times made it a lot easier to improve the documentation coverage. As of writing, the overall completion percentage is 97%. With additional efforts from contributors like you, we can perhaps reach 100% completion in the future.

Team reports for class reference pull requests

Another way for contributors to organize pull requests and work through the backlog is to use the team reports website. This website was built for contributors to check all open pull requests in a more convenient fashion than using GitHub’s web interface. Using this website, it’s easier to see when pull requets were last active and whether they are in a mergeable state (which may not be the case due to merge conflicts).

This website only tracks the main Godot repository on GitHub, not the documentation repository. With that said, in the context of the documentation, this is still relevant since all contributions to the class reference are sent to the main Godot repository. (The documentation repository only hosts a generated copy of the class reference from the XML source files.)

Godot Team Reports

User notes system

In 2024, the Godot documentation got an integration for user notes using Giscus. This allows users to share additional information relevant for documentation readers. This integration is currently present on the 4.4, 4.5, stable, and latest branches of the documentation.

As an example, you can see it in action at the bottom of the GDScript reference manual page.

Why have user notes on the documentation?

The Godot documentation is an essential learning resource for new and returning users alike. However, the content can sometimes benefit from additional clarification not found on the page itself. Since it’s an officially-maintained resource, it also tries to limit the number of third-party resources it links to.

To resolve this problem, we’ve decided to introduce a user note system in the Godot documentation. Inspired by user-provided comment systems such as PHP’s, this allows the community to make the documentation more useful for everyone: not just for users, but also for engine developers.

It should be noted that user notes are different from the usual comments you’d find on a blog post. As described by the user-contributed notes policy, they are intended to be used to provide additional context for the documentation or link to community resources. They are not designed to report bugs or suggest features. When the documentation is incorrect or outdated, please open an issue on the godot-docs repository instead of leaving a user note.

How user notes are implemented

The user notes integration is powered by Giscus, an open-source script that allows integrating a GitHub Discussions thread on a web page. To do so, it automatically creates a discussion in a repository when the first comment on a page is posted. On the Godot documentation, pages are matched based on their file name, but several page matching modes are provided by Giscus depending on the website’s needs.

Being hosted on GitHub Discussions allows anyone with a GitHub account to comment. On the organizational side, this also reduces system administration overhead as no separate backend or database for hosting comments is required. Spam protection (a traditionally difficult topic with comment platforms) is handled on GitHub’s end, which has historically been quite effective at avoiding spam.

As a bonus, you can also watch the godot-docs-user-notes repository on GitHub to be informed of new user notes being added to documentation pages. Replying to user notes left by others is a good way to get started with documentation improvements, as many user notes bring new information that can be incorporated into the main page.

Conclusion

This organization allows more people to contribute in various ways, even with limited technical know-how. Not only does the documentation benefit from those opening pull requests, it’s also continuously improved every day by those posting user notes at the bottom of documentation pages. These user notes bring further clarifications and context to the manual pages, as well as linking to useful resources.

A massive thank you to all contributors to the documentation! As always, we welcome contributions to the documentation. The contribution process is well-documented, but you’re welcome to hop on the #documentation channel on the Godot Contributors Chat if you have any questions.

Support

If you would like to help with the development of these features, please consider supporting the project financially! More funding allows us to sponsor volunteer contributors and better respond to technical demands of project users.

Godot 4.5, making dreams accessible

2025-09-15T20:00:00+00:00

From mind-blowing effects now made possible by the stencil buffer to accessibilty descriptions of your GUI elements that opens up the possibility for some with disabilities to play your game — we are proud to present to you Godot 4.5.

Release candidate: Godot 4.5 RC 2

2025-09-10T12:00:00+00:00

On Friday of last week, we dropped our first Release Candidate build. As a reminder, we release RC builds once we think the engine has stabilized and is ready for release. It is your last chance to report critical regressions before we release the stable version. Now, not even a full week later, we’re ready with our second snapshot. This RC2 fixes the last of the critical regressions that we are aware of. Unless someone reports a new regression coming from the changes made in RC1 or RC2, we should be on track to release 4.5 stable soon.

At this point in the process you will see the activity on GitHub slow down as we avoid merging work for 4.5. Our focus in the coming days will be on preparing the release, and queuing up all the changes we would like to merge early in the 4.6 release cycle.

The cover illustration is from Overlooting, a dungeon crawler where inventory management is crucial, as you must adapt your strategy to a skill tree that changes every run! You can buy the game on Steam, and follow the developers on Bluesky.

Highlights

For an overview of what’s new overall in Godot 4.5, have a look at the highlights for 4.5 beta 1, which cover a lot of the changes. This blog post only covers the changes between RC 1 and RC 2. This section covers all changes made since the RC 1 snapshot, which are largely regression fixes:

Animation: Move Skeleton3D init process (for dirty flags) into POST_ENTER_TREE from ENTER_TREE (GH-110145).
Buildsystem: Bump version to 4.5-rc (GH-110285).
Buildsystem: Fix Wayland build with OpenGL disabled (GH-110294).
C#: Fix the issue preventing installing C# binaries on Android devices with api <= 29 (GH-110260).
C#: Require net9.0 for Android exports (GH-110263).
Core: Fix Resource duplicate calls ImageTexture::set_image with an invalid image (GH-110215).
Editor: Fix “SpriteFrames” editor not fully hidding the bottom panel (GH-110280).
GDExtension: Fix WindowUtils::copy_and_rename_pdb regression (GH-110033).
Rendering: Metal: Ensure baked Metal binaries can be loaded on the minimum target OS (GH-110264).

Changelog

10 contributors submitted 9 fixes for this release. See our interactive changelog for the complete list of changes since the previous 4.5-rc1 snapshot. You can also review all changes included in 4.5 compared to the previous 4.4 feature release.

This release is built from commit 2dd26a027.

Downloads

Download Godot 4.5 rc2

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

During the Release Candidate stage, we focus exclusively on solving showstopping regressions (i.e. something that worked in a previous release is now broken, without workaround). You can have a look at our current list of regressions and significant issues which we aim to address before releasing 4.5. This list is dynamic and will be updated if we discover new showstopping issues after more users start testing the RC snapshots.

With every release, we accept that there are going to be various issues which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Godot is a non-profit, open source game engine developed by hundreds of contributors on their free time, as well as a handful of part or full-time developers hired thanks to generous donations from the Godot community. A big thank you to everyone who has contributed their time or their financial support to the project!

Release candidate: Godot 4.5 RC 1

2025-09-05T12:00:00+00:00

The final stage of development for Godot 4.5 has arrived: the Release Candidate. This means that all of our planned features are in place and the most critical regressions have been tackled, so we’re confident that it’s now ready for production use.

However, we can never be 100% sure that the release is ready to be published without very extensive testing from the community. So while Godot 4.5 is now ready for testing on existing projects (always make a copy/backup before upgrading, preferably with version control), we’re eager to hear how it fares and whether any new major issues have gone unnoticed until now.

While we are confident that we are nearly ready to release. There will be at least one more RC release after this one containing bug fixes for exporting C# projects to certain, older, Android devices and for shipping baked shaders on iOS devices. We have fixes in the queue already and anticipate merging them promptly and releasing an RC2 early next week. If no major regressions are reported with RC1/RC2, we anticipate releasing 4.5 stable shortly after.

The cover illustration is from Whimside, a creature collector where your pixel art companions keep you company at the bottom of your screen. You can buy the game on Steam, and follow the developer on Bluesky or YouTube.

Highlights

We covered the most important highlights from Godot 4.5 in the previous 4.5 beta 1 blog post, so if you haven’t read that one, have a look to be introduced to the main new features added in the 4.5 release.

Especially if you’re testing 4.5 for the first time, you’ll want to get a condensed overview of what new features you might want to make use of.

This section covers the most relevant changes made since the beta 7 snapshot, which are largely regression fixes:

Core: Fix regression in mechanism to hold objects while emitting (GH-109770).
Core: Make SceneTree not crash when receiving a notification without a root being set (GH-110041).
Editor: Add single-object inspect command backwards compatible API for potential regression (GH-110043).
Editor: Fix Range scale overflow (GH-110107).
Export: Fix editor export plugins always causing resources to be edited (GH-110057).
GUI: Do not set flags when PopupMenu::set_visible is called to hide popup (GH-110049).
Input: Fix Input.get_joy_info() regression after the SDL input driver PR (GH-108214).
Porting: macOS: Process joypad input directly in the embedded process (GH-109603).
Rendering: Add GENERAL resource usage to the render graph and fix mutable texture initialization in D3D12 (GH-110204).
Rendering: MSDF: Fix outline bleed out at small sizes (GH-110148).

Changelog

As we’ve tightened our policy on what kind of changes can be merged leading to the release candidate stage, there aren’t a lot of changes in this snapshot. 18 contributors submitted 24 fixes for this release. See our interactive changelog for the complete list of changes since the previous 4.5-beta7 snapshot.

This release is built from commit 6c9aa4c7d.

Downloads

Download Godot 4.5 rc1

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

During the Release Candidate stage, we focus exclusively on solving showstopping regressions (i.e. something that worked in a previous release is now broken, without workaround). You can have a look at our current list of regressions and significant issues which we aim to address before releasing 4.5. This list is dynamic and will be updated if we discover new showstopping issues after more users start testing the RC snapshots.

With every release, we accept that there are going to be various issues which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Bug reports

Support

Godot XR update - August 2025

2025-09-02T12:00:00+00:00

Godot XR Community Game Jam

Starting on 8 September 2025 the Godot XR Community is hosting its fourth Godot XR game jam.

Participants have a week to put together a small XR game using the Godot Game Engine. In addition, special consideration will be given to participants using the Godot XR editor to create their entry!

This is a great way to try out some XR development and hone your game design skills, as well as provide feedback to help improve the XR editor.

We invite you to take this opportunity to try out Godot as an XR platform! The XR channel on the official Godot Discord is a great place to get help.

Creating a game entirely in the XR editor

And on the topic of using the XR editor to create an XR game, during the Godot Wild Jam in May, David and Logan challenged themselves to create their entry entirely in VR - without using their PCs at all!

In this devlog video by Logan, they explain how it went:

Were they successful? Watch to find out!

Pre-release channels on HorizonOS

To improve development and testing of the XR editor, we have set up DEV, BETA, and RC (release candidate) pre-release channels in the Horizon store to provide the community with pre-release builds of the XR editor.

Interested users can self-subscribe to the pre-release channels using the following links:

After joining the pre-release channels, users can change the XR editor active channel by visiting the app’s “Settings” page in-headset, or via the “Version” dropdown in the app’s store page.

Render models support coming in Godot 4.5

Render models is a new API added to OpenXR 1.1.49 that provides access to various 3D assets accessible in the runtime.

Its main focus is to provide accurate render models for the physical controllers the player is using and accurately placing those in the virtual world. These models come with metadata and tracking data that result in full animation of these assets. Thus they react properly to button presses and other interactions the player is performing.

The implementation in Godot was made possible thanks to the Godot Integration Project that Khronos is currently funding and allowed Godot to implement this logic early. In doing so, runtime implementations could be tested and this provided feedback that allowed this API to be published.

SteamVR added support for this API in their 2.12 release.
PICO has added support for this API in their 5.14.0 release, currently supporting PICO 4 Ultra devices.
Other vendors are expected to provide support in the near future.

Dev snapshot: Godot 4.5 beta 7

2025-08-29T12:00:00+00:00

While we initially anticipated our next snapshot to begin release candidate phase, we left open the possibility of another beta pass if any significant blockers persisted. And while the overwhelming majority have since been handled, this extra pass is to ensure debug symbols are supported for Android platforms. While this was always something that could be done when building from source, a long-term goal is official access to debug symbols, making this something we want to get right out of the gate.

The cover illustration is from Strange Jigsaws, a game of strange jigsaws! You can buy the game on Steam, and follow the developer on YouTube or Bluesky.

Highlights

For an overview of what’s new overall in Godot 4.5, have a look at the highlights for 4.5 beta 1, which cover a lot of the changes. This blog post only covers the changes between beta 6 and beta 7. This section covers the most relevant changes made since the beta 6 snapshot, which are largely regression fixes:

3D: Create an undo/redo action when pinning a SoftBody3D point in the editor (GH-109828).
Audio: Web: Fix AudioStreamPlayer.get_playback_position() returning incorrect values for samples (GH-109790).
Core: Revert “Prevent crashing if max_threads is zero.” (GH-110003).
Documentation: Document ClassDB not storing information on user-defined classes (GH-109747).
Editor: Allow extending previously-non-abstract scripts that became abstract (GH-109903).
Editor: Don’t start editor as unsaved (GH-109825).
Input: Revert “[Web] Disregard touch events in pointer callbacks” (GH-109936).
Porting: Android: Fix safe area regression on older Android versions (GH-109818).
Rendering: Treat missing variants as normal cache misses during shader cache lookup (GH-109882).

Changelog

29 contributors submitted 47 fixes for this release. See our interactive changelog for the complete list of changes since the previous 4.5-beta6 snapshot.

This release is built from commit 4ebf67c12.

Downloads

Download Godot 4.5 beta7

Linux

macOS

Windows

Export templates and other downloads Make a Donation

Standard build includes support for GDScript and GDExtension.

.NET build (marked as mono) includes support for C#, as well as GDScript and GDExtension.

Known issues

During the beta stage, we focus on solving both regressions (i.e. something that worked in a previous release is now broken) and significant new bugs introduced by new features. You can have a look at our current list of regressions and significant issues which we aim to address before releasing 4.5. This list is dynamic and will be updated if we discover new showstopping issues after more users start testing the beta snapshots.

With every release, we accept that there are going to be various issues which have already been reported but haven’t been fixed yet. See the GitHub issue tracker for a complete list of known bugs.

Godot Engine Official

Dev snapshot: Godot 4.6 beta 2

Highlights

Changelog

Downloads

Godot is downloading...

Known issues

Bug reports

Support

Inverse Kinematics Returns to Godot 4.6

Godot 4.4

SkeletonModifier3D / LookAtModifier3D

RetargetModifier3D

Godot 4.5

SpringBoneSimulator3D

BoneConstraint3D (and 3 child classes)

Godot 4.6

IKModifier3D (and 7 child classes)

Tweak BoneConstraint3D

BoneTwistDisperser3D

LimitAngularVelocityModifier3D

Deterministic IK

Looking back on the journey

Support

Dev snapshot: Godot 4.6 beta 1

Highlights

Breaking changes

Animation

Audio / Video

Core

Documentation

Editor

GDExtension

GDScript

GUI

Import

Input

Internationalization

Navigation

Physics

Platforms

Android

Linux

Windows

Rendering and shaders

XR

Changelog

Downloads

Godot is downloading...

Known issues

Bug reports

Support

Dev snapshot: Godot 4.6 dev 6

Highlights

GDScript: Tracy profiler support

Android: Storage Access Framework support

And more!

Changelog

Downloads

Godot is downloading...

Known issues

Bug reports

Support

Dev snapshot: Godot 4.6 dev 5

Highlights

Use D3D12 by default on Windows

Add support for delta encoding to patch PCKs

Dedicated build app for Gradle builds on Android

Moving OpenXR forward

Massive optimizations to the 2D renderer

And more!

Changelog

Downloads

Godot is downloading...

Known issues

Bug reports

Support

Godot XR update - November 2025

“The Museum of All Things” released on the Meta Quest store!

Results of the Godot XR Community Game Jam

Animation: Add `SkeletonModifier3D` IKs as `IKModifier3D`

`ObjectDB` profiling tool