EditorFileSystem in Godot – Complete Guide

Managing resources and understanding your project’s file system is crucial for any game development process, particularly when it comes to platforms like Godot 4. With complex projects, you need an efficient way to handle various assets and ensure they are up to date. That’s where Godot’s EditorFileSystem class comes into the picture, providing a comprehensive look at your game’s resources from the editor’s perspective.

What is EditorFileSystem?

The EditorFileSystem is a class in Godot 4 that represents the project’s resource filesystem as seen by the editor.

It includes vital information on all resources within your project, such as their types and paths, and provides methods to interact with and update the resource system programmatically.

What is it for?

This subsystem of Godot serves as the backbone for managing resources in the editor, from keeping track of file types to reimporting assets.

Whether you’re a beginner seeking efficient resource management or an experienced developer looking to automate parts of the development process, mastering EditorFileSystem can simplify the workflow in significant ways.

Why should I learn it?

Learning to use the EditorFileSystem allows for dynamic and script-based management of your project’s assets.

By doing so, you can automate tedious tasks, ensure assets are up-to-date with their latest versions, and maintain a well-organized project structure, all of which are crucial components to a successful game development workflow.

CTA Small Image

Interacting with the Editor File System

Understanding how to work with the EditorFileSystem in Godot 4 is crucial. Let’s explore some examples on how to use this class for efficient asset management.

The first step is often to make sure the file system is up-to-date, which can be accomplished with the update or scan methods:

var editor_file_system = EditorFileSystem.get_singleton()
editor_file_system.scan()  # Perform full filesystem scan

Once you’ve ensured the file system is up to date, you can check if a file or directory exists within your project:

var path = "res://some_asset.png"
var exists = editor_file_system.file_exists(path)
print("Does the file exist? ", exists)

After confirming that the file exists, you might want to get information about it, like its type or modification time:

var file_info = editor_file_system.get_file_info(path)
print("File Type: ", file_info.get_type())
print("Modification Time: ", file_info.get_modification_time())

Managing Resources

Managing your game’s resources effectively can keep your project organized and maintain a good workflow. For instance, if you want to reimport a file to update its properties, you can do it like this:

editor_file_system.scan() # Make sure the filesystem is up to date

Managing dependencies between resources is also vital to prevent issues during runtime. You can find all files that a particular resource depends on:

var dependencies = editor_file_system.get_file_dependencies(path)
for dependency in dependencies:
    print("Dependency: ", dependency)

Conversely, knowing which resources rely on a particular asset can be just as important:

var users = editor_file_system.get_file_users(path)
for user in users:
    print("User: ", user)

In case you added or removed assets from your project, updating the filesystem is necessary. Using the update_file method will update a single file without scanning the entire project:

editor_file_system.update_file(path) # Up-to-date information on a single file

Remember to periodically synchronize the EditorFileSystem to ensure that all modifications are reflected:

editor_file_system.scan() # Full scan
# Do your file manipulation...
editor_file_system.save_changes() # Write changes to disk

These examples provide a good foundation for understanding how to manage assets within Godot 4 using the EditorFileSystem. By practicing these methods, you can effortlessly automate asset management tasks in your projects.

Extending the functionality of the EditorFileSystem, you can also connect to relevant signals to automatically respond to file system updates. Here’s how to connect to the ‘filesystem_changed’ signal:

editor_file_system.connect("filesystem_changed", self, "_on_filesystem_changed")

func _on_filesystem_changed():
    print("The filesystem has changed!")

If you need to find out about all the scripts in your project, you can use the get_script_classes method:

var script_classes = editor_file_system.get_script_classes()
for script_class in script_classes:
    print("Script: ", script_class)

Dealing with large projects means tons of resources. To keep things optimized, it’s a good idea to remove unused resources from your project:

editor_file_system.scan() # Start with an up-to-date filesystem
var unused_files = editor_file_system.get_filesystem_changed_files()
for unused_file in unused_files:
    print("Removed unused file: ", unused_file)

Moving a resource is a common task, which can be done programmatically as well. After moving a resource, make sure to update the filesystem so it recognizes the new resource location:

var old_path = "res://old_folder/my_resource.tscn"
var new_path = "res://new_folder/my_resource.tscn"

editor_file_system.move_file(old_path, new_path)
editor_file_system.update_file(new_path)  # Now the filesystem knows about the new path

In scenarios where you need to rename a directory, this is the method you will use and remember to save the changes:

var old_dir = "res://old_folder_name"
var new_dir = "res://new_folder_name"

editor_file_system.rename_dir(old_dir, new_dir)
editor_file_system.save_changes()  # Apply rename to the filesystem

Getting a list of all files in a specific directory can help you iterate over assets:

var files_in_directory = editor_file_system.get_directory_files("res://my_folder")
for a_file in files_in_directory:
    print("File in my_folder: ", a_file.get_name())

You may also want to find assets of a specific type. The following example demonstrates how to find all PNG files in a project:

var all_files = editor_file_system.get_file_list("res://")
for a_file in all_files:
    if a_file.get_type() == "Image":
        print("Found an image file: ", a_file.get_path())

Every time you perform operations that change the resource structure, it is important to save the EditorFileSystem’s state. Not doing so might result in Godot’s editor not recognizing the latest changes to your project’s files:

editor_file_system.save_changes()  # Make sure to save after any significant change

By leveraging the examples above, you can manipulate and maintain your game assets in Godot 4 with ease. Whether it’s connecting signals for automatic updates, moving resources, or cleaning up unused assets, the EditorFileSystem class empowers developers to better manage their project files.

For those who want to get even more detailed information about files and resources, you can use the get_file_info function. This example shows how to print the script path of a scene if it has one:

var scene_path = "res://my_scene.tscn"
var file_info = editor_file_system.get_file_info(scene_path)
if file_info.has_script():
    print("The script associated with the scene is: ", file_info.get_script_path())

It’s also common to categorize assets and identify which ones need to be reimported based on particular criteria. Below is how to identify all textures that have been imported with a lossless compression mode:

var all_files = editor_file_system.get_file_list("res://")
for file in all_files:
    if file.get_type() == "Texture" and file.get_metadata("importer", "lossless_compression_mode"):
        print("This texture has been imported with lossless compression: ", file.get_path())

Automating the reimport process with a specific set of parameters can save you a lot of time, especially when working with large batches of assets. The following snippet demonstrates this by reimporting all textures with a new set of import flags:

for texture_path in editor_file_system.get_file_list("res://textures"):
    editor_file_system.file_reimport(texture_path, import_flags)

Sometimes, you may want to perform an action after a scan has completed, like checking for missing files that haven’t been updated. You’ll need to put your process in a function that’s connected to the ‘filesystem_updated’ signal:

editor_file_system.connect("filesystem_updated", self, "_on_filesystem_updated")

func _on_filesystem_updated():
    # Example function called after the filesystem has been updated
    var missing_files = editor_file_system.get_missing_files()
    if missing_files.size() > 0:
        print("There are missing files after the scan!")
        for missing_file in missing_files:
            print("Missing file: ", missing_file)

Version control can be essential when dealing with a team, and you may need to find out which files have conflicted versions. The get_changed_files function can help you pinpoint these files:

var changed_files = editor_file_system.get_changed_files()
for changed_file in changed_files:
    if changed_file.is_conflicted():
        print("This file has a version conflict: ", changed_file.get_path())

Finally, proper clean-up is as essential as creation and updates. When you delete a resource from Godot’s editor, it’s important to ensure that it’s removed from the filesystem. Here’s how to programmatically delete a resource:

var file_to_delete = "res://unused_asset.tres"
if editor_file_system.file_exists(file_to_delete):
    print("File successfully removed: ", file_to_delete)
editor_file_system.save_changes()  # Save the filesystem changes

With these examples, you should have a much clearer understanding of how to work with the EditorFileSystem class in Godot 4. Such knowledge allows for a more fluid and responsive development experience by efficiently managing the large number of assets typically found in game projects. Whether you’re a solo developer or working in a team, leveraging these tools will help keep your project files in good order and your development process smooth.

Where to go next?

Congratulations on enhancing your knowledge of managing resources in Godot 4 using the EditorFileSystem class. You’ve taken an important step towards mastering the ins and outs of the Godot engine, and we’re excited to see where you go from here.

If you’re eager to keep learning and expanding your Godot expertise, our comprehensive Godot Game Development Mini-Degree offers a rich curriculum designed to take you further. Dive into various aspects of game development such as 2D and 3D design, GDScript programming, and building different gameplay mechanics. Whether you’re just starting or looking to specialize, these structured courses hold the knowledge you need to advance in your game creation journey.

For a broader exploration of what we have to offer, visit our full collection of Godot courses. With Zenva, you can learn at your own pace and craft an impressive portfolio with real-world projects. Let us accompany you on your path from beginner to professional game developer. Keep learning, keep creating, and you’ll be amazed at what you can achieve!


In mastering the EditorFileSystem in Godot 4, you’ve unlocked a powerful ally in the world of game development. With the skills you’ve acquired, you’re ready to manage and organize your game project’s assets like a pro. Automation, efficiency, and a clean project structure are now part of your development toolkit, ensuring that you can focus more on creativity and less on menial tasks.

But why stop here? Continue to grow your abilities with our Godot Game Development Mini-Degree, where even more game development secrets await. As you step further into this exciting journey with Zenva, remember that every line of code you write and every asset you manage is a stepping stone towards building your dream games. So keep learning, keep experimenting, and let the adventures in game design never cease!

Python Blog Image

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