Dev snapshot: Godot 4.5 beta 1

The first beta release for the 4.5 release cycle has come at last, and with it a plethora of outstanding bugs to be squashed. Contributors are encouraged to focus exclusively on fixing regressions, as we are now in feature-freeze and will not be merging new features at this stage of development (aside from a couple pre-approved exceptions scheduled for beta 2).

For those interested in aiding us on our quest to squash any bugs that come up during this time, we encourage you to join our recent bug-hunting sprints. Helmed by our new head of the Bugsquad, A Thousand Ships has taken to hosting regular sprints for tackling various bugs within the Godot repo, organized such that everyone can easily gather behind a given theme to make chunks of fixes as seamlessly and speedily as possible. This will be our fourth sprint of this type, with an associated discussion already prepared. See 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 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 Rift Riff, a tower defense game whose layered combat isn’t compromised by its variety of forgiving mechanics! You can buy the game on Steam. You can follow the developers on Bluesky: Adriaan, Sim, Franz, Matthijs, Panda.

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, and dev 5).

Much like previous feature releases, a lot of major features have managed to squeeze in right before the feature freeze! Those weren’t covered in previous articles, so we’ll also be showcasing the main changes added between 4.5 dev 5 and beta 1. Given the recency of those last minute merges, most of them are somewhat experimental compared to the more traditional highlights later on in the article, so please let us know if any issues are encountered.

• Breaking changes
• Animation
• Audio / Video
• C#
• Core
• Documentation
• Editor
• 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.5 milestone with the breaks compat label. Here are some which are worth being aware of:

• Tilemap physics are now handled in chunks. Only affects get_coords_for_body_rid, as now a single body can cover multiple cells. (GH-102662)
• Internal nodes are no longer duplicated. Only affects users deliberately utilizing internal nodes. (GH-89442)
• NodeOneShot fading now uses self delta instead of input delta. Brings behavior closer to other AnimationNodes, as the old implementation was exclusive to NodeOneShot. (GH-101792)
• 2D & 3D Navigation region and link updates are now asynchronous. (2D: GH-107381, 3D: GH-106670)
• NavigationServer2D avoidance callbacks changed from Vector3 to Vector2. (GH-107256)
• Removed the gradle_build/compress_native_libraries export option. With Android builds now supporting 16kb pages, the native libraries are now required to be uncompressed. (GH-106359)
  • We are considering re-introducing this option for users who don’t target Android 16, or distribute APKs outside of Google Play. (GH-107681)
• “Areas Detect Static Bodies” setting removed from Jolt Physics, this is now always enabled. (GH-105746)
• set_scope removed from JSONRPC. Manual method registration is now required via set_method. (GH-104890)

Animation

This might be a little more technical than usual, but the work Tokage put into implementing BoneConstraint3D warrants a highlight all the same (GH-100984). With this new class, users will be able to bind a bone to another bone, opening the door for more natural movements and poses.

Twist:

Disabled	Enabled

Bend:

Onto something more suitable for a blog post highlight: UX improvements! YeldhamDev implemented support for selection box movement and scaling within the bezier editor, making it a piece of cake to perform changes to points in batches (GH-100470). Arnklit continues the bezier improvements with GH-95564, allowing users to auto tangent new points in a balanced or mirrored manner. The animation player gets some love as well, with the ability to sort animations alphabetically (GH-103584). Lastly, and featured below, is a very long-awaited UX improvement: animation filtering! (GH-103130)

And more:

• Add delta argument to SkeletonModifier3D _process_modification() and expose advance() in Skeleton3D. (GH-103639)

Audio / Video

Berama brings us the ability to seek Theora video files via the new set_stream_position function (GH-102360). In doing so, they’ve additionally improved our multi-channel audio resampler, meaning that videos with 6+ channels will no longer crackle. A much more technical breakdown & additional features can be gleaned from the PR.

And more:

• Add metadata tags to WAV and OGG audio streams. (GH-99504)

C#

First-time contributor Justin Sasso kicks things off with linux-bionic RID export support (GH-97908). For those that don’t speak buildsystem, this enables NativeAOT on Android! For those that don’t speak .NET lingo, “NativeAOT” refers to the ability for .NET applications to compile directly to a device’s native code, bypassing the need for the .NET runtime entirely. NativeAOT apps have the benefit of significantly faster startup and smaller memory footprints, which are both very welcome additions for mobile devices.

Finding performance improvements in an interop context is like finding a needle in a haystack. Actually tracking down where some point of slowdown or inefficency is taking place across entirely different environments is difficult to the point that most people won’t even attempt it. Delsin-Yu is not most people, because the improvements that came from simply removing StringName allocations on unimplemented getters/setters saw a staggering 60× decrease in resources (GH-104689).

Not everything related to .NET was able to make it in time for 4.5, but they’re still worth mentioning because of how much effort the team has already put into them. For instance: we’re well aware of the excitement around bringing .NET to web builds for Godot, and progress on that front has been very promising. We’ve even covered this very topic in a previous blog, where we discussed the rocky road of bringing this project to light even featured a prototype which you can try right now!

Our other long-term project for C# is revolving around the gradual move to GDExtension. The current module approach, while entirely functional for what it is, has historically been a fairly hacky implementation. Grafting on interop functionality between the engine itself and the dotnet runtime has proven to be error-prone, leading to a disproportionate amount of man-hours sunk into ensuring everything functions as expected. The hope is for the move to GDExtension to mean that all interop calls are handled in a manner that’s universally applicable; that is: a manner that any programming language could take advantage of.

And more:

• Android: Add a preload hook to load .NET assemblies from the APK. (GH-105262)
• Android: Load .NET assemblies directly from PCK. (GH-105853)

Core

Changes to the core of the engine require significantly more scrutiny than other parts of the engine; this comes down to how critical and foundational virtually every single piece of code proves to be. This makes it all the more impressive that there’s so much worth highlighting in 4.5 that’s specific to core!

Adding a way to properly log errors and warnings, as well as get backtraces in logs when they happen, was among the most highly-requested features from our users for years. By their powers combined, Mikael Hermansson and Juan Linietsky have added script backtracing support for GDScript and C# (GH-91006). Finding the root problem behind warnings/errors that appear at runtime required being able to reproduce them in the editor to use the debugger. Developers will now have the possibility to see backtraces of runtime errors directly in their logs, making it possible to debug and fix issues that happen under user testing or in shipped titles. This functionality is always available in debug mode, but can be activated in release mode for GDScript if Debug > Settings > GDScript > Always Track Call Stacks is enabled in the project settings.

func _ready():
	my_func1()

func my_func1():
	my_func2()

func my_func2():
	print(Engine.capture_script_backtraces()[0])

Outputs:

GDScript backtrace (most recent call first):
    [0] my_func2 (res://node_2d.gd:11)
    [1] my_func1 (res://node_2d.gd:8)
    [2] _ready (res://node_2d.gd:5)

Pedro J. Estébanez also addressed a long-time complaint with Resource.duplicate(true) not performing the expected deep duplication in a reliable and predictable way (GH-100673). The new behavior of the method, and the additional Resource.duplicate_deep() give users full control over what gets duplicated or not (arrays, dictionaries, nested resources, etc.).

Additionally, special thanks to Lukas Tenbrink, a new addition to the core team who has been contributing nonstop improvements to ensure optimal performance for developers and maintainers alike.

And more:

• Add Node.get_orphan_node_ids, edit Node.print_orphan_nodes. (GH-83757)
• Don’t duplicate internal nodes. (GH-89442)
• Use Grisu2 algorithm in String::num_scientific to fix serializing. (GH-98750)
• Add scene_changed signal to SceneTree. (GH-102986)
• Complete build profile feature to properly detect options that can be disabled (reducing binary size). (GH-103719)
• Add thread safety to Object signals. (GH-105453)

Documentation

It’s not often that we have the opportunity to cover documentation changes in these highlights, as those changes are usually fairly low-key. This isn’t to say that changes aren’t happening; on the contrary, it’s one of the single most active areas of our GitHub! That’s because it often goes beyond our main repo, with changes needing to be synchronized in godot-docs. Special shoutouts to Mickeon for the class reference, and Matthew, tetrapod, A Thousand Ships, Max Hilbrunner and Hugo Locurcio for the online docs, for taking on the lion’s share of pull requests and reviews.

Haoyu Qiu’s addition of required as a qualifier within the documentation itself warrants special mention (GH-107130). When extending a class that has virtual methods, it wasn’t immediately obvious which methods needed an override, versus having defaulted fallbacks. …Well, it was obvious if you looked at the descriptions, but it wasn’t something inherent to the functions themselves like const. This won’t be an issue moving forward, as now required will come right after virtual where applicable.

Anyone who has contributed to the documentation has likely wrangled with the mixed-indentation of codeblocks. This necessitated adding spaces manually, and often meant disabling autoformatting on XML files; this was inconvenient at best & outright error-prone at worst. Tomasz Chabora put this issue to rest with GH-89819, unilaterally replacing all spaces with tabs across all codeblocks. This was a surprisingly involved process, as it required a simultaneous freeze & subsequent update of our localization files, but where there’s a will there’s a way!

Editor

First-time contributor daniel080400 came out of the gate swinging with PR GH-102313, which entirely overhauled the way scene preview thumbnails are handled.

3D thumbnails are captured at a consistent angle from the world center, ensuring all contents fit into the screen. Particles are fast-forwarded slightly in order to render something, utilizing a fixed seed.

2D thumbnails utilize two passes—2D and GUI—before combining the two for the final image. As prefabs generally don’t care about world coordinates, the world center is not accounted for with 2D thumbnails.

A rarely-covered topic regarding the editor is the command palette, but we’ll happily make an exception to highlight HolonProduction’s PR GH-99318 adding named EditorScripts to the command palette! This much more centralized means of execution serves to benefit the commands that are more project-specific. This is specifically for named scripts however, such that there will always be an associated display name and search handling.

As for topics we have covered, where better to start than with Variant exporting? This functionality is brought to life by Tomasz Chabora, bringing support for a dynamic variable in a standalone context (GH-89324). With the ability to change not only the variable, but the type itself, the doors are wide open for creative integrations in the inspector.

And more:

• Override editor settings per-project. (GH-69012)
• Inspector section toggles. (GH-105272)
• “Mute Game” toggle in Game view. (GH-99555)
• Drop preload Resources as UID. (GH-99094)
• Allow selecting multiple remote nodes at runtime. (GH-99680)
• Add emission shape gizmos to Particles2D. (GH-102249)
• Search script docs without manual recompilation. (GH-95821)
• Array drag-and-drop improvements. (GH-102534)
• Add meshes to Video RAM Profiler. (GH-103238)
• Add “Paste as Unique” option to editor resource picker. (GH-103980)

GDScript

4.5 sees with it the introduction of a new keyword: abstract. Aaron Franke brings this previously internal-only functionality into the hands of all GDScript users (GH-67777). By prepending this keyword to a class, it ensures that direct instantiation cannot occur; meaning that all calls will actually refer to a derived classes. Danil Alexeev built further upon this by introducing the ability for users to declare functions as abstract (GH-106409). By prepending the same abstract keyword to a function, it will be marked for explicit override by child classes.

Note: The GDScript team is planning to change the abstract keyword to an @abstract annotation during the 4.5 beta phase.

abstract class Item:
	abstract func get_name() -> String

	func use() -> void:
		print("Character used %s." % get_name())

class HealingPotion extends Item:
	func get_name() -> String:
		return "Healing Potion"

func _ready() -> void:
	var potion := HealingPotion.new()
	potion.use() # Prints `Character used Healing Potion.`

	var item := Item.new() # Parser error!

Danil isn’t done yet though, as variadic arguments support (GH-82808) comes from him as well! In programming languages, variadic arguments allow functions to accept a flexible number of input parameters. This allows turning the final argument of a function into an array that is called as if it were a sequence.

func f(a: int, b: int = 0, ...args: Array):
	prints(a, b, args)

func _ready() -> void:
	f(1)
	f(1, 2)
	f(1, 2, 3)
	f(1, 2, 3, 4)
	f(1, 2, 3, 4, 5)

# Output:
# 1 0 []
# 1 2 []
# 1 2 [3]
# 1 2 [3, 4]
# 1 2 [3, 4, 5]

GDScript also saw a lot of usability improvements for the script editor, with notably fixes to code completion and highlighting:

• Inline color pickers. (GH-105724)
• Highlight warning lines. (GH-102469)
• Don’t add parenthesis when expecting Callable. (GH-96375)
• Autocompletion for @export_tool_buttons. (GH-105081)
• Autocompletion for user methods. (GH-106198)
• Highlighting script members like native ones. (GH-74393)
• Code completion for overridden user-defined methods. (GH-106198)

GUI

Here at the Godot Foundation, accessibililty is an absolute top-priority. The road to making an experience available to anyone regardless of their circumstances isn’t an easy one, but it’s a road that all developers are obligated to take. To that end, our resident tech guru bruvzg tackled the absolutely Herculean task of integrating AccessKit to Godot as a whole (GH-76829). With this in place, screenreader support is now built into the very core of the engine. All our supported desktop platforms offer fully uncompromised support, as the bindings are already in place and well-tested. When other platforms follow suit, we will ensure support to the absolute best of our ability.

4.5 is bringing with it quite a few new quality-of-life improvements, with one of the biggest additions being one we actually haven’t given proper coverage to yet: foldable containers! Tomasz Chabora is no stranger to editor enhancements, and this time he has blessed us with GH-102346, which grants us the new FoldableContainer class. Now users can have dynamically cascading GUI objects with the ability to toggle if the contents are expanded or not at will, a process that previously took several workarounds to achieve.

In a similar vein, the ability to manipulate a group of controls simultaneously has become much easier thanks to Delsin-Yu’s PR with a focus on recursive control across child controls (GH-97495). This implements new properties for recursively disabling Focus Mode and Mouse Filter, meaning that the ability to select and interact with child controls becomes far more intuitive, and allows for explicit overrides if desired.

There’s also the newly added SVGTexture, implemented by our very own bruvzg in GH-105375, allowing for rasterization of SVG files directly. However, when initially showcased, this process was fairly long-winded, as the main uses were internal. This has since been remedied with a dedicated importer in GH-105655, making rasterization much more accessible to all users.

And more:

• TextEdit/LineEdit: Add support for OEM Alt codes input. (GH-93466)
• Stackable outlines on Label. (GH-104731
• Replace global oversampling with overrideable per-viewport oversampling. (GH-104872)
• RichTextLabel: Add paragraph separation theme property. (GH-107331)

Import

Godot 4.0 introduced the Advanced Import Settings dialog, which allows configuring how to import specific 3D assets with great flexibility. This dialog kept being improved upon in subsequent releases (including 4.5), but one part of its workflow became a major pain point for users: the ability to batch edit multiple assets to assign an external material to all of them was gone, forcing users to configure this in each asset individually using the Advanced Import Settings dialog. bruvzg corrected this oversight by reintroducing options in the Import dock to configure whether to extract materials in a way that supports multi-asset configuration (GH-107211).

And more:

• Add Channel Remap settings to ResourceImporterTexture. (GH-99676)
• Use UIDs in addition to paths for extracted meshes, materials and animations. (GH-100786)
• Allow attaching scripts to nodes in the Advanced Import Settings dialog. (GH-103418)
• Use libjpeg-turbo for improved jpg compatibility and speed. (GH-104347)

Input

While it’s not yet integrated in beta 1, you can gather all your gamepads and joysticks in anticipation of the integration of SDL3 as Godot’s new gamepad input driver for desktop platforms (GH-106218). Up until now Godot had its own “joypad” platform drivers inspired from earlier versions of SDL, but not as full-featured. Over time, issues accumulated in our implementation while SDL kept maturing, and it’s now a net positive to defer the responsibility for this subsystem to a well established cross-platform library. If all goes well, this change should be merged for beta 2 as an exception to the feature freeze. Thanks in advance to Nintorch for bringing this contribution to the finish line, building upon earlier work of Álex Román Núñez and Xavier Sellier.

Internationalization

Internationalization has always been an extremely crucial part of the Godot project, and its relative lack of coverage in our blogposts does not do it justice. Haoyu Qiu allows us to break this bad habit of ours with a fantastic addition to the i18n workflow: editor previews (GH-96921)! Now there’s much less guesswork necessary to see how your projects will appear to the end-user in their native language, ensuring a consistent and clean style no matter the selection!

Translation preview on Michael Alexsander’s Librerama:

Similarly, the ability to swap languages on-the-fly within the editor is now possible thanks to the efforts of Tomasz Chabora in GH-102562. Now users can preview and experience multiple language options in a single editor session.

We also want to give a shout-out to all the translators who tirelessly work on localizing the Godot editor, the class reference and the online documentation. If you’d like to join that effort, head to Weblate and review our documentation for instructions.

Navigation

The navigation team has been able to really spread their wings thanks to logic for 2D and 3D being handled independently. smix8 took the mantle on the initial split, while A Thousand Ships brought the logic to the module system itself. This opened the door for improvements to performance across both navigation systems, and helps decrease the size of builds which exclusively target 2D.

The work started by smix8 in 4.4 to make navigation map synchronization asynchronous (GH-100497) was expanded for this release by applying the same treatement to navigation regions (3D: GH-106670, 2D: GH-107381).

And more:

• Add navigation path query parameter limits. (GH-102767)

Physics

Our implementation of 3D fixed-timestep interpolation has been completely overhauled, as the previous iteration had fundamental flaws with how it was structured in such a way that couldn’t be addressed with a simple fix or patch. The solution already existed on 3.x, and has since been forward-ported by lawnjelly via GH-104269. Now all logic is handled within the SceneTree, but in a manner which doesn’t break any existing API. All projects will benefit from this improvement out-of-the-box.

Interpolation with 10 ticks per second:

Working in tandem since the integration of Jolt Physics as new 3D physics engine in Godot 4.4, Mikael Hermansson and Jorrit Rouwe (Jolt’s creator) have made nearly 20 fixes and improvements to the Jolt integration for Godot 4.5, which should now provide an even better experience.

And more:

• Add ability to apply forces and impulses to SoftBody3D. (GH-100463)
• Chunk tilemap physics. (GH-102662)
• SoftBody3D: Support physics Interpolation. (GH-106863)

Platforms

Android

The Android editor experience has become significantly improved thanks to the implementation of TouchActionsPanel. While this is technically something any touch device can take advantage of, Anish Mishra’s PR GH-100339 was explicitly created with the Android editor in mind. TouchActionsPanel comes equipped with common action buttons (save, undo, redo, etc.), which simulate actions like ui_undo and ui_redo via pre-existing shortcuts.

And more:

• Add support for using an Android Service to host the Godot engine. (GH-102866)
• Enable native debug symbols generation. (GH-105605)
• Add CameraFeed support. (GH-106094)
• Bump minimum supported SDK to 24. (GH-106148)
• Add support for 16KB page sizes. (GH-106358)

Linux

Riteo has been on a quest to turn Wayland into a true replacement for the X11 protocol. The biggest reason to not switch over as the default implementation, the lack of native sub-windows, is no longer a concern thanks to GH-101774. Now users can truly take advantage of multi-window output, regardless of display protocol. This being solved, the next step will be to implement in-editor game window embedding to have full parity with the X11 flavor of the editor. Riteo already started that work in GH-107435.

macOS

Speaking of embedding the game window! It took an extra release cycle for this Godot 4.4 feature to come to macOS, as this OS does not allow the kind of window manipulation that Windows and Linux/X11 use for game window embedding. Instead, macOS utilizes an inter-process communication approach where the framebuffer is sent from the game process (which performs off-screen rendering) to the editor window, which also handles passing input events to the game process. Although it’s much more complex, Stuart Carnie used a more robust approach that doesn’t rely on any window management hacks (GH-105884). Not having to worry about edge-cases or low-level shenanigans is appealing in its own right, so this approach may be ported later to Windows/Linux in a future release to make game window embedding much more reliable overall.

And more:

• Switch ANGLE (OpenGL ES compatibility layer) to Metal backend. (GH-107306)

visionOS

The Apple XR environment, visionOS, comes to Godot Engine in 4.5! We’re already committed to making great strides in XR feature sets and support, but this brings us closer to a platform-independent pipeline similar to what we already have with traditional platforms. It might be unconventional to imagine using an engine editor within an XR environment, but it’s one which we’ve supported for Meta Quest and OpenXR; now Apple users can join the fun.

This work was contributed by Ricardo Sanchez-Saez from Apple’s visionOS engineering team. A notable consequence of this PR is that our iOS and visionOS platforms now share a unified “Apple Embedded” driver, which paves the way to implementing tvOS support in the future.

Web

The upcoming performance boost from SIMD is so impressive that we’ve made a dedicated article to showcase exactly what kind of benefits users can expect. The short version is that Adam Scott created a PR which changed only a single compiler flag (GH-106319), but one which caused universal improvements for web applications and editor workflow. Check out our article for the long version.

Marcos Casagrande started contributing during this release cycle and brought a flurry of performance improvements to the Web platform, which should further help ensure that web games work on as many devices as possible.

Windows

Support for Windows 7/8.1 will be dropped starting with 4.5 (GH-106959). The call to remove Windows 8.1 wasn’t a difficult one; it’s been EOL for over half a decade, had extended support end over two years ago, and was inherently unpopular to the point that online survey tools for OSes outright omit it. Windows 7 is comparatively more contentious, but builds for it were already in a broken state ever since the introduction of the aforementioned AccessKit; combine that with Windows 7 recently celebrating its 10-year anniversary of being EOL, as well as active coverage of this OS being estimated at one-tenth of a percentage point, and its removal was ultimately cemented. This had the benefit of significantly cleaning up the codebase for our Windows-specific files, which often had to rely on dummy includes to account for Windows 7 specifically, and opens the door for more modern APIs to be integrated for our Windows builds.

Another major improvement to the Windows export pipeline is the possibility to modify the metadata of Windows binaries without the third-party rcedit tool (GH-75950). This means that Godot can now properly set a custom icon to your Windows .exe, and modify the relevant product name, company information, etc., fully out of the box and from any platform.

And more:

• Remove visible WINDOW_MODE_FULLSCREEN border by setting window region. (GH-88852)
• Official Windows binaries are now signed with a new code signing certificate (provided by Prehensile Tales).

Rendering and shaders

Stencils!

With a PR in the making for nearly 2 years GH-80710, apples has brought a long-awaited stencil support to Godot! This new shader functionality is supported on all of our rendering backends, and will allow our users to perform entirely new techniques with the power of depth.

Standard outline, standard x-ray, and custom outline materials:

Custom x-ray material:

Cel-shaded lighting:

Fire effect implemented entirely with StandardMaterial3D:

Shaders and rendering features

In addition to the stencil shader support, 4.5 brings with it a plethora of improvements to those working with shaders. One such usability improvement arrived via GH-100287, where Yuri Rubinsky re-organized the shader editor’s UI as a whole. Others are in the form of direct rendering improvements, such as: ambient specular occlusion by Lander (GH-106145), SMAA support by Raymond DiDonato (GH-102330), and bent normal maps by Capry (GH-89988).

Specular occlusion:

Disabled	Enabled

SMAA:

Off	On

Bent normal maps:

Before	After

Shader baker

Just as essential to rendering as the output itself is how performant it is to create that output in the first place. Darío and Pedro J. Estébanez bless us in this respect with GH-102552, which introduces a new shader baker at export time. When enabled, all shaders will be pre-compiled at export time, ensuring that players won’t need to wait a long time for shaders to compile when running your game. Users don’t have to put in any extra work to make this work with ubershaders, as the features go hand-in-hand automatically.

Before:

After:

Motion vectors for Mobile

Across our multiple renderers, it’s only reasonable that certain features would be exclusive to the higher-end selections. Motion vectors, for instance, have been available on the Forward+ renderer for ages, but have never been available to the Mobile renderer. That is, until Logan Lang took to rectifying this in GH-100283, which builds atop his previous PR’s render-agnostic foundation.

And more

• Add new StandardMaterial properties to allow users to control FPS-style objects (hands, weapons, tools close to the camera). (GH-93142)
• Fragment density map support. (GH-99551)
• Implement motion vectors in mobile renderer. (GH-100283)
• Overhaul the cull mask internals for Lights, Decals, and Particle Colliders. (GH-102399)
• Various performance optimizations. (GH-103547, GH-103794, GH-103889)
• Optimize Mobile renderer by using FP16 explicitly. (GH-107119)
• Fix LightmapGI shadow leaks. (GH-107254)

XR

The XR team has been doing a lot of groundwork to support more OpenXR extensions. While it’s separate from the main Godot release cycle, the Godot OpenXR Vendors had a 4.0.0 release in April which is worth checking out! Matthieu Bucchianeri had a massive first contribution merged to implement support for the Direct3D 12 OpenXR backend (GH-104207).

Darío and Logan Lang’s implementations of respectively fragment density maps and motion vectors for the Mobile renderer also pave the way for better rendering and supporting more extensions for XR.

While these are not merged yet, you can keep an eye on Bastiaan Olij’s cutting edge implementations for the OpenXR Spatial Entities (GH-107391) and Render Model (GH-107388) extensions, building upon the freshly released OpenXR SDK 1.1.49. Fredia Huya-Kouadio is also putting finishing touches on the support for running hybrid apps from the Godot XR editor (GH-103972).

Changelog

334 contributors submitted a staggering 1817 fixes since the release of 4.4-stable. See our interactive changelog for the complete list of changes. You can also review changes since the 4.5-dev5 snapshot, for a more curated selection of 372 fixes from 119 contributors.

This release is built from commit 46c495ca2.

Downloads

Download Godot 4.5 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.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.

• Windows: As mentioned above, we used a new signing certificate for this release. Windows Defender’s SmartScreen might pop up for initial downloads as it sees a surge of downloads of binaries signed with a legit but yet unused certificate. This should automatically rectify itself by the time beta 2 rolls around.
• Android: Subsequent exports fail when using Shader Baker. The workaround is to delete the .godot/export before exporting. (GH-107535)
• Wayland: Wayland editor documentation popups appear on screen’s edge and generate errors. (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 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!

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.