EditorExportPlatform in Godot – Complete Guide

Welcome to the first steps into the world of Godot 4, an open-source game development platform loved by indie developers and enthusiasts alike. With its powerful scripting and scene management capabilities, Godot enables creators to bring their visions to life with efficiency and a touch of coding magic. If you’ve ever dreamed of exporting your game to various platforms seamlessly, the EditorExportPlatform class is a toolkit essential to understand and master. It is the bridge between your game in the Godot editor and the myriad of devices waiting to run your creation.

In this series, we’ll delve into the intricacies of the EditorExportPlatform class – a cornerstone for cross-platform game development using Godot 4. Whether you’re just starting your coding journey or you’re an experienced developer eager to expand your skillset, this tutorial promises to enrich your understanding and show you why mastering game exporting is as crucial as developing the game itself.

What is EditorExportPlatform in Godot 4?

The EditorExportPlatform class in Godot 4 is a fundamental part of the Godot engine’s tooling that identifies and manages exports to supported platforms. It does more than just export your project; it allows you to store platform-specific metadata, configure platform-specific customizations, and oversee the entire export process.

What is it For?

When you’re ready to share your game with the world, EditorExportPlatform makes sure your game pops up on screens across various devices. From the powerful PCs to the handy smartphones, this class handles the nuts and bolts of getting your project out of the editor and onto the platforms of your choosing.

Why Should I Learn it?

Understanding how to use the EditorExportPlatform can be a game-changer for your Godot projects. Here’s why it’s valuable:

– It opens doors to multiple platforms, maximizing your game’s reach.
– Knowing the export process can save you from last-minute hassles before launch.
– It gives you control over platform-specific features and optimizations.

Stay with us as we explore the possibilities unlocked by the EditorExportPlatform class in Godot 4, and learn how you can take your game from the confines of the editor to the expanse of the gaming world.

CTA Small Image

Getting Started with Exporting in Godot 4

Let’s dive into the application of EditorExportPlatform in your Godot 4 projects. To start, you need to understand how to access export presets from a script. It’s simple with the `EditorExport` singleton which provides methods to manage your export presets:

var export_presets = EditorExport.get_export_presets()

Each preset corresponds to exporting to a different platform. To illustrate, if you want to iterate over all presets and print their names, you can do this:

for preset in EditorExport.get_export_presets():
    print("Preset Name: ", preset.name)

Now that we know how to access the presets, we’ll need to actually perform an export. It’s done by calling the `export_project()` method on the `EditorExport` singleton. Here’s an introductory example:

var export_preset = EditorExport.get_export_preset('Windows Desktop')
var export_path = "user://my_game.exe"
var export_flags = EditorExport.FLAG_EXPORT_BUNDLE 
EditorExport.export_project(export_preset, export_path, export_flags)

Note that `export_project()` requires you to specify the export preset along with the file path for the exported project and the export flags.

Handling Export Flags and Signals

The `EditorExport.export_project()` method contains important flags that can modify the behavior of the export:

– `FLAG_EXPORT_BUNDLE` is used when you want to export the project as a bundled package.
– `FLAG_DRY_RUN` can be used to run a test export without writing the actual files.

Here is how you can use the `FLAG_DRY_RUN`:

EditorExport.export_project(export_preset, export_path, EditorExport.FLAG_DRY_RUN)

It’s also crucial to handle export signals to know when the export process starts, completes, and if it encounters any errors. To connect these signals, you might do the following:

EditorExport.connect("export_begin", self, "_on_export_begin")
EditorExport.connect("export_finished", self, "_on_export_finished")
EditorExport.connect("export_error", self, "_on_export_error")

func _on_export_begin():
    print("Export has begun")

func _on_export_finished():
    print("Export has finished")

func _on_export_error():
    print("An error occurred during the export")

With these signals connected, your script will now respond to the export process, giving you feedback on its status or any issues.

Setting Up Platform Specific Export Options

Often, you’ll want to tailor your game export settings for specific platforms. With EditorExportPlatform, you can set options such as screen orientation for mobile platforms or feature flags for desktop. Let’s look at how that is achieved:

For instance, to set the orientation for an Android export, you might use the following code:

var preset = EditorExport.get_export_preset('Android')
preset.set_option("screen/orientation", "portrait")

If you need to enable a feature for a desktop platform, the process is just as straightforward:

var preset = EditorExport.get_export_preset('Windows Desktop')
preset.set_option("graphics/3d", true)

These examples highlight the power of EditorExportPlatform to customize your exports per platform with suitable configuration options.

Exporting Resources and Handling File Paths

Your games often include resources like textures, sounds, and scripts. Here’s how you can ensure that they’re included in your export:

When setting up your export preset, you can define what types of resources should be included or excluded using `export_filters`:

var preset = EditorExport.get_export_preset('HTML5')
preset.add_export_filter("*.png", true)  # Include all PNG files
preset.add_export_filter("*.wav", false) # Exclude all WAV files

To handle file paths during export, Godot provides the `Resource`’s `export_path` property. You can set it like so:

var resource = preload("res://icon.png")
resource.export_path = "user://icons/icon.png"

By knowing how to manage resource exporting and understanding file paths handling, you’re one step closer to creating a fully functioning and portable game ready to be enjoyed by a worldwide audience.

Stick with us for the next installment where we’ll demonstrate more advanced exporting techniques, including scripting nuances and debugging your export process. With every line of code, we’re not just building games—we’re crafting experiences!

Advanced Export Techniques in Godot 4

Moving forward with our deep-dive into Godot’s exporting capabilities, let’s explore more nuanced aspects of the EditorExportPlatform. Get ready to smooth out your game’s transition from development to deployment by mastering these advanced techniques.

Debugging Exports

Debugging is an integral part of game development, and this includes the export process. You must know how the export platform manages errors. Here’s how you can check if there were errors after an export attempt:

var result = EditorExport.export_project(export_preset, export_path, export_flags)
if result != OK:
    push_error("Export failed with error code: " + str(result))

This snippet runs an export and checks the result. If there’s an issue, it uses Godot’s built-in `push_error()` method to alert you to the problem.

Exporting Scheduled Jobs

Sometimes, you may want to schedule an export to occur after a certain condition or at a specific time. To manage this, Godot can make use of timers:

var timer = Timer.new()
timer.wait_time = 3600 # Wait for 1 hour
timer.one_shot = true
timer.connect("timeout", self, "on_timer_timeout")

func on_timer_timeout():
    EditorExport.export_project(export_preset, export_path, export_flags)

The above example sets a timer to wait for an hour before executing the `on_timer_timeout()` method, which runs the export.

Exporting Different Builds

When releasing a game, you may want to create different builds, like a ‘debug’ build or a ‘release’ build. This can be achieved by modifying export options dynamically:

func export_build(preset_name, export_path, debug_mode):
    var preset = EditorExport.get_export_preset(preset_name)
    preset.set_option("application/run_mode", "Debug" if debug_mode else "Release")
    EditorExport.export_project(preset, export_path, EditorExport.FLAG_EXPORT_BUNDLE)

export_build('Windows Desktop', "user://my_game_debug.exe", true)
export_build('Windows Desktop', "user://my_game_release.exe", false)

Using `set_option()`, you can switch between debug and release modes for your presets and call `export_build()` to create the corresponding versions of your game.

Customizing Exported Files

Sometimes, you might need to add custom files to your export, like configuration files or license texts. This can be done by editing the `export_files` property of the export preset:

var preset = EditorExport.get_export_preset('Windows Desktop')
preset.export_files.append("res://LICENSE.txt") # Assumes you have a LICENSE.txt file in your Godot project

By appending files to the `export_files` list, they’ll be included in your export.

Modifying Export Templates

To provide even further customization, you may need to modify export templates. Export templates are what Godot uses as a base to create your game’s executable and other binary files. While altering templates is more complex, Godot’s EditorExportPlatform class makes it possible:

var export_template_zip = "user://my_export_template.tpz"
EditorExport.export_project_with_custom_templates(export_preset, export_path, export_template_zip, export_flags)

In this case, `export_project_with_custom_templates()` allows you to specify a .tpz (template package zip) file that contains your custom templates.

Automating the Process for Continuous Integration

Many development environments benefit from continuous integration (CI) systems. You can automate Godot exports as part of a CI pipeline with shell scripts or by using the command line:

# Example shell command for CI automation
godot --export "Windows Desktop" "path_to_project.exe" --no-window --quit

This shell command runs Godot in headless mode, exports the project for Windows Desktop, and then closes Godot.

Through these advanced techniques, we glimpse the power and flexibility of the Godot engine’s exporting capabilities. Armed with this knowledge, you can streamline your deployment process and resolve issues that might have once been obstacles on your path to publishing. Keep experimenting with these tools to fully harness Godot 4’s capabilities and, as always, let your creativity lead your game development journey to new and exciting destinations!Continuing with our exploration of Godot 4’s export capabilities, let’s delve into more specific scenarios and solutions you might encounter.

Filtering Platform-Specific Code

In game development, you may have certain code that’s relevant only for specific platforms. Godot’s export system allows you to include or exclude files based on the platform. For example, if you have a script that should only run on Windows, you can add a filter to include it only when exporting for Windows:

var preset = EditorExport.get_export_preset('Windows Desktop')
preset.add_export_filter("res://platform_specific_windows_code.gd", true)

Similarly, you could exclude this script from other platforms:

var preset = EditorExport.get_export_preset('Linux/X11')
preset.add_export_filter("res://platform_specific_windows_code.gd", false)

Setting Up Scenes for Different Platforms

Different platforms may require different starting scenes. You can set the main scene for each export preset:

var preset = EditorExport.get_export_preset('Android')
preset.set_option("application/main_scene", "res://Main_Mobile.tscn")

This ensures that “Main_Mobile.tscn” will be the starting scene when exported for Android.

Configuring Export Preset Before Exporting

You can also modify preset configurations right before exporting to ensure that the latest settings are applied:

func configure_and_export(preset_name, export_path):
    var preset = EditorExport.get_export_preset(preset_name)
    # Set additional configurations here
    preset.set_option("application/config/name", "My Awesome Game")
    var export_result = EditorExport.export_project(preset, export_path, EditorExport.FLAG_EXPORT_BUNDLE)
    if export_result != OK:
        push_error("Failed to export: " + str(export_result))
configure_and_export('HTML5', 'user://my_game.html')

This function configures the project name for the preset before triggering the export, guaranteeing up-to-date information in your build.

Automating Versioning in Exports

Automatically appending build numbers or version information during the export process can aid in organizing your builds:

func export_with_versioning(preset_name, export_path, version):
    var preset = EditorExport.get_export_preset(preset_name)
    preset.set_option("application/config/version", version)
    EditorExport.export_project(preset, export_path, EditorExport.FLAG_EXPORT_BUNDLE)

export_with_versioning('Windows Desktop', 'user://My_Game_v1_0_0.exe', '1.0.0')

By passing in a version string, you can add the corresponding version information to your exported game.

Accessing Custom Features

Sometimes, your export may need to activate custom features of the engine or third-party modules:

var preset = EditorExport.get_export_preset('Windows Desktop')
preset.set_option("custom_features", "my_custom_feature")

This code snippet tells the engine to include your custom feature in the export for the Windows Desktop platform.

Post-Export Scripts

Post-export scripts are great for tasks you’d like to run immediately after the export completes. Binding a signal to a custom method can allow you to automate post-export procedures:

EditorExport.connect("export_finished", self, "_on_post_export")

func _on_post_export():
    # Post-export tasks like copying files, generating additional data, etc.
    print("Export complete. Running post-export tasks...")

This method becomes a perfect place to initiate any subsequent actions required after your game has been exported.

Exporting with Custom Build Modes

For more control over the build process, you may need to create custom build modes:

var preset = EditorExport.get_export_preset('iOS')
preset.set_option("custom_build/debug", true)
preset.set_option("custom_build/shipping", false)

This approach is beneficial when you have unique build configurations, particularly for complex projects or those requiring specific optimizations for each platform.

With these hands-on code examples and explanations, your mastery over Godot 4’s export process will continue to grow. Always remember that a smooth export flow can be as innovative as the game itself, ensuring a seamless transition from development to the end user’s hands. Keep refining your export strategy, and the quality of your releases will reflect the dedication you’ve put into every aspect of the game development process!

Continuing Your Journey in Game Development

Congratulations on taking definitive steps toward understanding the export process in Godot 4! You’ve come a long way, but mastering game development is a continual journey filled with learning and growth. To keep advancing your skills and to explore more about game creation using Godot, we encourage you to check out our Godot Game Development Mini-Degree. This program is designed to equip you with the knowledge to build cross-platform games and delve deeper into the many facets of game design and programming.

Whether you’re just starting out or looking to build on your existing knowledge, Zenva’s courses cater to all levels. Explore our broad collection of Godot courses to find content that suits your learning pace and interests. Learn coding, create games, and earn certificates at your convenience. You can go from beginner to professional with Zenva.

Remember, each game you create is not just a product—it’s a portfolio piece, a learning experience, and a step toward a thriving career in game development. Stay curious, keep learning, and let your creativity lead the way!


As our exploration of the EditorExportPlatform in Godot 4 concludes, you’re now equipped with valuable insights to not only traverse the complexities of the export process but to do so with confidence. The ability to harness this knowledge and apply it effectively to your projects is what will distinguish your games in a market teeming with creativity. Remember, every export is a bridge connecting your imagination to the players eager for new adventures.

Keep pushing the boundaries of what’s possible, and if you thirst for more knowledge or seek to refine your skills further, join us on the full journey by exploring our comprehensive Godot Game Development Mini-Degree. Here at Zenva, we’re excited to be a part of your game development story, providing you with the tools to transform your visions into reality. Happy developing!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.