EditorPaths in Godot – Complete Guide

Navigating the world of game development can be as exciting as it is intricate, especially when it comes to understanding the tools that power our creations. In the realm of Godot, a popular open-source game engine, one such tool is the EditorPaths class available in Godot 4. This class is a beacon for game developers, guiding them through the sometimes murky waters of file and folder management within their projects. Managing where your game saves its cache, configuration, and data is vital for both development and post-deployment, ensuring a smooth experience for developers and players alike. In this tutorial, we will unpack the functionality of the EditorPaths class and provide clear examples of how to use it effectively in your Godot 4 projects, catering to developers beginning their journey and those with more experience under their belt.

What is the EditorPaths Class?

The EditorPaths class serves as an editor-only singleton that offers consistent and reliable paths to various data folders and files, which are crucial for maintaining a project’s hygiene. It is platform-specific, ensuring that no matter where your Godot editor is running, it can interact with the filesystem in a way that’s expected on that OS.

What is it for?

EditorPaths is designed to be utilized within editor plugins to guarantee that files are saved in the appropriate locations. It serves an important purpose by providing safe paths for cache data, user configuration files, and even project-specific settings—all tailored to the operating system you are working on.

Why Should I Learn It?

Harnessing the power of EditorPaths can greatly enhance the development process, making it more organized and efficient. Learning how to use this class enables you to create editor tools that are both robust and adaptable across different platforms. Moreover, understanding EditorPaths is a step towards mastering Godot’s editor environment, providing you the ability to customize and extend the engine to fit your needs.

CTA Small Image

Accessing Standard Path Locations

In game development, having ready access to specific path locations within the Godot editor is a common necessity. Using EditorPaths, you can retrieve the paths to standard locations, such as your configuration or cache files. This is particularly important for creating and managing editor plugins or handling project-specific settings. Here are some examples of how to access these standard path locations using the EditorPaths class:

// Access the Godot editor's configuration path.
var config_path = EditorPaths.get_configuration_dir()

// Access the Godot editor's cache path.
var cache_path = EditorPaths.get_cache_dir()

// Access the Godot editor's data path.
var data_path = EditorPaths.get_data_dir()

// Access the Godot editor's script templates path.
var script_templates_path = EditorPaths.get_script_templates_dir()

Each method call returns a string containing the absolute path to the respective directory on the filesystem. This way, you can write or read files to the proper location without hardcoding paths, making your plugins more portable and easier to manage.

Managing Project-Specific Settings

The EditorPaths class also includes methods to help manage settings specific to the current project. For instance, when creating editor tools that need to maintain state or configuration between sessions, it’s valuable to know where to store these settings. Below are examples of how to leverage EditorPaths for project-specific data:

// Access the current project's settings path.
var project_settings_path = EditorPaths.get_project_settings_dir()

// Access the current project's addons path.
var project_addons_path = EditorPaths.get_project_addons_dir()

// You might want to store custom data or configs for your plugin in the project.
var custom_config_path = "${project_settings_path}/my_plugin_config.cfg"

// Saving a configuration file specific to your project.
var file = File.new()
if file.open(custom_config_path, File.WRITE) == OK:

In the example above, we first obtain the directories specifically for the project’s settings and addons. Then, we extend this by creating our own configuration file path, which we use to open a new file, write a string to it, and then close the file. This will save our custom plugin configuration with the project, ensuring it’s available the next time the project is opened.

Creating and Using Custom Project Paths

Sometimes you need more flexibility and wish to define custom directories within your project to keep your workflow organized. With EditorPaths, creating directories for various assets or files related to your editor tool is straightforward:

// Define a custom path for storing level designs within your project
var custom_level_path = OS.get_user_data_dir() + "/my_game/level_designs"

// Check if the directory exists, if not, create it
var dir = Directory.new()
if not dir.dir_exists(custom_level_path):

// Now you can write level files to this directory
var level_file_path = "${custom_level_path}/level1.json"
var level_content = '{"name": "Level 1", "enemies": 10, "items": 5}'

// Saving a level design file
var file = File.new()
if file.open(level_file_path, File.WRITE) == OK:

In this example, we are creating a custom directory for level designs. After checking and ensuring the directory exists, we create a new level file and write some JSON content into it. This demonstrates how you can manage file creation and directory structures within a defined path using EditorPaths, maintaining clean organization for your project’s assets.Continuing with the practical applications of the EditorPaths class in Godot 4, it’s often crucial to not only create and manage paths but also to retrieve and handle various files within those directories. This calls for methods to traverse, search, and manipulate files and directories, critical for efficient tool development. Below you’ll find additional examples demonstrating these capabilities.

To start, let’s look at how to retrieve a list of script files within a given directory:

// List all script files in a specific directory
var scripts_directory_path = EditorPaths.get_script_templates_dir()
var dir = Directory.new()
if dir.open(scripts_directory_path) == OK:
    var file_name = dir.get_next()
    while (file_name != ""):
        if file_name.ends_with(".gd"):
            print("Found script: " + file_name)
        file_name = dir.get_next()

Here we use the list_dir_begin and get_next methods to iterate over all items within the scripts directory. We check for files ending with the “.gd” extension, which are Godot script files, and print their names.

Next, consider how we might copy a specific file from our project into a user’s application data directory:

// Copy a file from the project directory to user's application data directory
var source_file_path = "res://defaults/config.txt"
var target_file_path = EditorPaths.get_data_dir() + "/config.txt"
var file = File.new()

if file.open(source_file_path, File.READ) == OK:
    var content = file.get_as_text()
    if file.open(target_file_path, File.WRITE) == OK:
        print("File copied to: " + target_file_path)

Here we read the contents of a file located within the project and then store those contents into a new file at a target path within the user’s application data directory provided by EditorPaths.

Additionally, we might want to ensure the integrity of our file handling by checking for the existence of a file before we attempt to manipulate it:

// Check if a file exists before attempting to read or write
var potential_file_path = EditorPaths.get_data_dir() + "/user_prefs.cfg"
var file = File.new()

if file.file_exists(potential_file_path):
    print("User preferences file exists.")
    // Operations on the existing file can go here
    print("User preferences file does not exist. Creating new file.")
    // Handle creating a new file here

By checking for a file’s existence, we can branch our logic accordingly, ensuring we handle both cases where a file might or might not already be in place.

Moreover, if we want to delete a file, we can easily do so by calling the remove method:

// Deleting a file
var file_to_delete = EditorPaths.get_cache_dir() + "/obsolete_cache.dat"
var file = File.new()

if file.file_exists(file_to_delete):
    var result = file.remove(file_to_delete)
    if result == OK:
        print("File successfully deleted.")
        print("Failed to delete file.")

In this example, we check if the file exists first to avoid errors and then proceed to delete it. This is part of good practice when handling file operations.

Using the EditorPaths class alongside Godot’s file management APIs provides extensive control, facilitating custom tool development and enhancing overall project organization. It allows for clear distinctions between content, helping to maintain clean directory structures and streamline development workflows, which is essential in the dynamic environment of game development.Let’s take your mastery of EditorPaths and file operations even further. To build powerful editor tools and manage game resources efficiently, we often need to handle bulk operations on files and directories, manage temp files, and understand the editor’s resource operation signals. Here are various scenarios where advanced usage of EditorPaths and file management comes into play, with code examples to guide you.

Firstly, let’s consider a common scenario where you want to batch-rename a group of asset files within a specific directory:

// Batch rename asset files in a directory
var assets_directory = "res://assets/sprites"
var dir = Directory.new()
if dir.open(assets_directory) == OK:
    var file_name = dir.get_next()
    while (file_name != ""):
        if file_name.ends_with(".png"):
            var new_file_name = "renamed_" + file_name
            dir.rename(file_name, new_file_name)
        file_name = dir.get_next()

By appending a prefix to each .png file, we’re mass-renaming asset files within the “sprites” directory. Remember, error checking after each operation is a best practice that ensures the stability and reliability of your tools.

Now let’s manage temporary files, which are often required for intermediate processing:

// Create and manage a temporary file
var temp_file_path = EditorPaths.get_cache_dir() + "/temp_data.tmp"
var file = File.new()

// Write to the temporary file
if file.open(temp_file_path, File.WRITE) == OK:
    file.store_line("Temporary content")

// Remember to delete the temporary file when done
if file.file_exists(temp_file_path):

Creating a temporary file in the editor’s cache directory allows you to manipulate data without cluttering the user’s directories. We also responsibly delete the temp file after use, which is important for maintaining a clean filesystem.

Handling user preferences is another typical use case. We want to load these at startup and save changes:

// Load user preferences at startup
var prefs_file_path = EditorPaths.get_data_dir() + "/user_prefs.cfg"
var user_prefs = {}
var file = File.new()

// Read existing preferences or create a default file
if file.file_exists(prefs_file_path):
    if file.open(prefs_file_path, File.READ) == OK:
        user_prefs = parse_json(file.get_as_text())
    // Set default preferences
    user_prefs = {"theme": "dark", "auto_save": true}
    if file.open(prefs_file_path, File.WRITE) == OK:

In this snippet, we’re ensuring user settings are maintained across sessions by loading them at the start and keeping the ability to write back to the file. JSON is utilized for easy human readability and parsing simplicity.

Lastly, let’s automate asset importation by responding to file system changes:

// Automatically import assets when new image files are added to the project
var watched_directory = "res://assets/new"
var dir = Directory.new()

func _notification(what):
    if what == MainLoop.NOTIFICATION_WM_FOCUS_IN:
        if dir.open(watched_directory) == OK:
            var file_name = dir.get_next()
            while (file_name != ""):
                if file_name.ends_with(".png"):
                    // Use Godot's import logic over new PNG files here
                    print("New image to import: " + file_name)
                file_name = dir.get_next()

func _ready():

// Here we are assuming you have some logic to import images
// This would typically be connected to a signal or a regular check in the process loop

This advanced usage involves checking a directory every time the Godot window regains focus, typically when a user switches back to Godot after adding new assets. Such automation can significantly streamline the resource import workflow.

Through these examples, we can see that EditorPaths provides a firm foundation for intricate file and directory operations within the editor. It lends itself to the construction of robust tools and plugins for Godot, which is invaluable for both solo developers and teams looking to expedite their game development process.

Where to Go Next

Embarking on the journey to master Godot and game development is thrilling, and there’s always more to explore and create. If you’ve enjoyed diving into the capabilities of the EditorPaths class and strive to deepen your understanding of Godot 4, our Godot Game Development Mini-Degree is the perfect next step. Designed to build a strong foundation and advance your skills, this comprehensive collection will guide you through creating cross-platform games with hands-on projects that cement learning and inspire creativity.

With Zenva, we make learning flexible and accessible, understanding that each developer’s journey is unique. You’ll find something to suit your pace and interests, from beginner concepts to more advanced game mechanics. For a broader exploration of what we offer, including various game genres and coding practices, head over to our Godot courses. These will provide you with an array of skills that are not just valuable, but essential to thrive in today’s game development landscape. So take the reins on your learning adventure and craft the games you’ve always dreamed of with Zenva!


Whether you’re starting your game development path or looking to hone your existing skills, the power and flexibility of the EditorPaths class in Godot 4 can take your projects to the next level. By mastering file and directory management within Godot’s robust framework, you’re equipping yourself with the tools necessary to create, innovate, and bring your gaming visions to life with precision and flair. Remember, each function you learn and utilize is a step closer to realizing your full potential as a game developer.

Never forget that with Zenva, you’re never alone on your educational journey. We are here to support, teach, and grow with you as you unlock the vast possibilities in game development. Dive deeper, build greater, and let your creations shine with Zenva’s Godot Game Development Mini-Degree. Empower your dreams with code, one line at a time, and ready your games for the world to enjoy!

Python Blog Image

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