EditorExportPlatformPC in Godot – Complete Guide

Welcome to a journey through the intricacies of the EditorExportPlatformPC class in Godot 4, a key component in bringing your game creations from the development environment to players’ desktops across the globe. As you embark on the creation of magnificent worlds and engaging game mechanics, understanding how to efficiently export your projects is just as crucial as the development itself. This tutorial aims to demystify the export process and guide you, regardless of whether you’re taking your first steps into game development or are looking to polish your skillset with comprehensive knowledge of Godot’s exporting capabilities.

What is EditorExportPlatformPC?

EditorExportPlatformPC is a cornerstone class in Godot 4’s engine, a part of its robust exporting system. It serves as the base class for desktop platforms, laying the groundwork for exporting games to Windows and Linux/BSD systems. As such, it is vital for ensuring your game can reach a wide audience on multiple operating systems.

What is it for?

Imagine crafting a beautiful and fun game, but when it comes to sharing it with the world, you hit a wall. The EditorExportPlatformPC class prevents this from happening by allowing developers to configure and streamline the export process, handling the often complex requirements and settings needed for games to run smoothly across different desktop platforms.

Why Should I Learn It?

Understanding the EditorExportPlatformPC class and its intricacies not only enables you to export your projects with confidence but also to customize the process to best fit your game’s and audience’s needs. Learning how to handle this class means breaking through the constraints of the development environment and stepping into the wider gaming community. You’ll be equipped with the knowledge to make your game accessible to players on their preferred systems, effectively increasing your game’s reach and success.

Diving into the EditorExportPlatformPC class is not only a technical necessity but a chance to give your game the wings it needs to soar across the diverse landscape of desktop gaming. Let’s walk through this path together and ensure that the products of your imagination are enjoyed by as many players as possible.

CTA Small Image

Setting Up Your Export Presets

Before diving into code examples, it’s crucial to set up your export presets in Godot. Presets are templates that save the settings you want for each export. Here’s how to create a preset for PC export:

# First, open your project in Godot and go to 'Project' > 'Export...'
# Select 'Add...' and choose the desired desktop platform

Once your preset is in place, you can adjust settings like export path, custom features, or include debug symbols. Now, let’s look at how to access these presets programmatically through the EditorExportPlatformPC class:

var export_presets = ProjectSettings.get_setting("export/presets")

for preset in export_presets:
    if preset["platform"] == "Windows Desktop":
        # This is your Windows preset. You can now interact with it.

Customizing the Export Template

To cater to specific game needs, you might want to modify the export template. In the following example, we’ll adjust the icon of an exported Windows game:

var preset_id = ... # ID of your Windows export preset
var exporter = EditorPlugin.get_editor_interface().get_export_preset_manager()
var windows_preset = exporter.get_preset(preset_id)
windows_preset.set("icon", "res://your_icon.ico")

Fine-tuning the export process can enhance the player’s experience by offering a more personalized game package.

Configuring Export Flags

Export flags can change details from compression methods to whether debug symbols are included. Below we’ll set flags to optimize the export size:

var preset_id = ... # ID of your Windows export preset
var preset = EditorPlugin.get_editor_interface().get_export_preset_manager().get_preset(preset_id)

preset.set("export_filter", "all_resources") # Include all resources
preset.set("include_debug_symbols", false)   # Do not include debug symbols
preset.set("optimize_for_size", true)        # Optimize for smaller size

Running the Export Process

With all settings tailored to your game, you can finally run the export process. Here’s how you programmatically export a preset through Godot’s EditorScript:

var export_task = EditorExportPresetTask.new()

After calling ‘run’, Godot will start exporting the game to the specified path, considering all the settings we’ve previously customized. With these building blocks, you can start to automate the exporting process of your Godot games, creating a smoother workflow that suits your development needs.

Stay tuned, as we delve deeper into practical examples in the following parts, granting you the mastery over exporting that is necessary for a successful game launch.

Automating the export of your games can save you time and help ensure consistency across different builds. Let’s explore more advanced usage of Godot’s export capabilities starting with the export mode configurations:

var preset_id = ... # Assume we have the preset ID as before
var preset = EditorPlugin.get_editor_interface().get_export_preset_manager().get_preset(preset_id)

# Set the export mode
preset.set("export_mode", "script_encrypted") # Options: exclude, script_encrypted

Configuring loop optimizations and stripping levels can further optimize your game:

preset.set("optimization/loop_optimization_level", "preload_and_optimize") # Other options are "only_optimize" and "unroll"
preset.set("optimization/stripping_level", "strip_all") # Reduce file size by stripping unused elements

You can even specify if you want to export specific resources or directories:

preset.set("resources/custom_resources", "res://my_custom_folder/")
preset.set("resources/custom_features", "my_custom_feature")

Sometimes, you might need to modify advanced export options. Below is how you can change the texture compression settings for better graphics performance:

preset.set("textures/compression_mode", "ram") # Use 'ram' for less VRAM usage, 'vram' for full-size textures

Path remapping is another powerful feature that allows you to change how resources are referenced in the exported game:

preset.add("remap/boot_splash_image", "res://new_boot_splash.png")
preset.add("remap/boot_splash_scale", "keep_width") # Options: keep, keep_width, keep_height, expand, scale

Lastly, ensure your game includes the required export templates. Here’s how you could programmatically check and alert about missing export templates:

if !EditorExportPlatformPC.has_export_template():
    print("Missing export templates for PC! Ensure they are downloaded and installed correctly.")

Using these code snippets, developers can automate vast sections of the export process, from optimization settings to resource management. This level of automation paves the way for batch processing multiple export presets, perhaps even integrating with version control systems for continuous delivery of your game’s builds. Godot’s scripting capabilities in combination with the EditorExportPlatformPC class empower developers to tailor the exporting process to their specific game requirements and workflows.

Keep experimenting, refine your exporting strategy, and watch as your game takes its final form, ready to be delivered into the hands of eager players. Stay with us as we continue to explore the vast possibilities of building and exporting games with Godot.

Moving forward with our venture into the world of exporting Godot projects, let’s look into handling the quality settings for 3D games. Adjusting the 3D rendering settings can have a significant impact on your game’s performance:

preset.set("rendering/quality/driver/driver_name", "GLES3") # Choose between GLES2, GLES3, Vulkan etc.
preset.set("rendering/quality/depth/hdr", true) # Enable High Dynamic Range
preset.set("rendering/quality/depth/depth_range", "stable") # Options: stable, wide

Now, let’s address exporting plugins. If you’re using any plugins that require exporting, you can specify them like so:

preset.set("plugins/plugin_name/enabled", true)
# Repeat the process for each plugin your game requires

If your game relies on locale and translations, you should also consider including specific localization files:

preset.set("locale/export_translations", true) # Include translation files
preset.set("locale/selected_locales", ["en", "es", "fr"]) # Specify which locales to include

Managing screen settings is also a critical part of the export process. This code snippet shows how to enforce fullscreen mode and set the window size:

preset.set("display/window/size/fullscreen", true) # Start in fullscreen
preset.set("display/window/size/width", 1920) # Window width
preset.set("display/window/size/height", 1080) # Window height

And if your game is targeting different input methods, you might want to configure input settings accordingly:

preset.set("input_devices/joypad/create_virtual_devices", 2) # Number of virtual joypads
preset.set("input_devices/pointing/emulate_touch_from_mouse", true) # Emulate touch input from mouse

Lastly, to assert that the game runs with a specific minimum OpenGL feature set (relevant for games relying heavily on graphics), you can use:

preset.set("rendering/quality/driver/fallback_to_gles2", false) # Don't fallback to GLES2
preset.set("rendering/quality/shading/force_vertex_shading", false) # Force vertex shading

By automating these configurations, you can tailor your exports to perform optimally for the platforms you’re targeting. The flexibility provided by the EditorExportPlatformPC class ensures that your game can be enjoyed as intended, regardless of where it’s being played.

We hope these examples have shone a light on the powerful features available in the Godot engine for exporting your games and shown you the breadth of control Godot offers for tailoring game exports. Embrace these capabilities to streamline your game development process, ensuring that your game looks and performs its best once it reaches your players.

Remember, at Zenva, we’re here to support you through every step of your game development journey. Keep experimenting with what you’ve learned, refine your process, and watch your games come to life.

Continuing Your Journey in Game Development

Embarking on the world of game development with Godot can be an exhilarating journey, filled with learning, discovery, and creation. We’ve covered some of the intricacies of exporting with EditorExportPlatformPC, but there’s so much more to explore within Godot 4’s vast capabilities.

To further your skills and continue building on the knowledge you’ve gained, we invite you to check out our Godot Game Development Mini-Degree. This comprehensive collection of courses will guide you step-by-step through everything from the basics of 2D and 3D game creation to more advanced topics such as UI systems and various game mechanics. You’ll learn by doing, creating an impressive portfolio of real projects that will showcase your ability to turn concepts into tangible games.

For those who seek a wider array of learning materials, our full selection of Godot courses awaits to deepen your expertise in different areas. Regardless of where you are in your game development journey, Zenva’s flexible and project-based learning options will help you propel your abilities from beginner to professional. Take the next step and make your dream games a reality with Zenva.


Exploring the EditorExportPlatformPC class within Godot 4 has provided us with the necessary tools to tailor and automate game exports, allowing for an efficient transition from game development to distribution. Remember, learning and growth are continuous processes in the realm of game development. With every new feature and technique mastered, you draw closer to bringing your inspired creations to the world’s stage.

We at Zenva are thrilled to be a part of your journey and look forward to seeing the incredible games you will produce. Don’t hesitate to level up your skills with our Godot Game Development Mini-Degree, where the possibilities are only limited by your imagination. Your pathway to professional game development is just a few clicks away—jump in and start creating today!

Python Blog Image

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