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

Standard

.NET

macOS

Standard

.NET

Windows

Standard

.NET

Export templates and other downloads


Make a Donation

Godot is downloading…

Godot exists thanks to donations from people like you. Help us continue our work:

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.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

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 ConvertTransform3D 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-path 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!

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.

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!

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 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).

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
      • CCDIK3D
      • FABRIK3D
      • JacobianIK3D
    • 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.

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.

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,ja,zh
Letter,Alphabet,Lettre,Буква,字母,字母
Letter,Message,Courrier,Письмо,手紙,信件

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).

Navigation

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.

dhoverb 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.

dhoverb has also 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

Standard

.NET

macOS

Standard

.NET

Windows

Standard

.NET

Export templates and other downloads


Make a Donation

Godot is downloading…

Godot exists thanks to donations from people like you. Help us continue our work:

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.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.

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 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!

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

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 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

Standard

.NET

macOS

Standard

.NET

Windows

Standard

.NET

Export templates and other downloads


Make a Donation

Godot is downloading…

Godot exists thanks to donations from people like you. Help us continue our work:

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

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 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!

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

Continue reading ➤

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 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).

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

Standard

.NET

macOS

Standard

.NET

Windows

Standard

.NET

Export templates and other downloads


Make a Donation

Godot is downloading…

Godot exists thanks to donations from people like you. Help us continue our work:

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

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 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!

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