EditorFileSystem in Godot – Complete Guide

When you’re embarking on the journey of game development, understanding the tools at your disposal is critical for efficient and creative workflows. In Godot, a powerful open-source game engine, there’s an unseen yet powerful ally in managing your project’s myriad resources – the EditorFileSystem class. This component is a game-changer for developers, as it stands guard over all the resources within your project, organizing and maintaining an efficient environment for creativity to bloom.

What is EditorFileSystem?
The EditorFileSystem class is an integral part of the Godot Engine, one that manages the resource filesystem as perceived by the editor. It’s not just about keeping files in order; this class houses functions that allow developers to access information, type, and states of all resources within the game’s filesystem, right from within the editor itself.

What is it for?
The primary purpose of EditorFileSystem is to provide developers with a suite of methods to interact with their game’s resources programmatically. It enables you to scan for changes, reimport altered files, inquire about file types, and monitor the progress of these operations—all this contributes to a more streamlined development process.

Why should I learn it?
A deep understanding of EditorFileSystem can not only save you time but also prevent errors that can arise from manually handling resources. You may not directly see its effects on your game, but it’s the behind-the-scenes maestro ensuring that everything runs smoothly and efficiently. Learning about EditorFileSystem will empower you to masterfully manage your game’s resources like a seasoned pro, and thus, our journey into unlocking its potential begins.

CTA Small Image

Scanning the Filesystem

To kick things off, let’s command Godot to check for any changes in the project’s files. We can do this by calling the scan() method on the EditorFileSystem. This process is asynchronous, so it doesn’t block the editor while it’s working.

var fs = EditorFileSystem.get_singleton()

After initiating a scan, you might want to know when it’s finished. You can connect to the filesystem_changed signal to get a notification:

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

func _on_filesystem_changed():
    print("The filesystem has been updated.")

This is particularly useful for updating UI elements or performing operations after new files have been added or old ones have been removed.

Getting Information About Files

Now, let’s fetch some details about a specific resource. We can use the get_file_info() method to retrieve an instance of EditorFileSystemDirectory which represents the directory in which the file is located.

var file_info = fs.get_file_info("res://path/to/your/resource.tres")
print(file_info) # Output could be an instance like: res://path/to/your/directory

Once we have the EditorFileSystemDirectory object, we can extract useful information about the contained files such as the name and type of the resources.

for i in range(file_info.get_file_count()):
    print("File Name: ", file_info.get_file(i))
    print("Type: ", file_info.get_file_type(i))

Checking for File and Directory Existence

Before you try to access a file or a directory, it’s good practice to check if it actually exists. The file_exists() and dir_exists() functions are used for this purpose:

var path_to_file = "res://path/to/resource.png"
var path_to_dir = "res://path/to/directory"

if fs.file_exists(path_to_file):
    print("The file exists!")
    print("The file does not exist.")

if fs.dir_exists(path_to_dir):
    print("The directory exists!")
    print("The directory does not exist.")

These methods are vital when writing scripts that need to handle resources dynamically. Checking for existence prevents errors caused by attempting to access non-existent resources.

Reimporting Resources

If you’ve made external changes to an image, model, or any other resource, you might want these changes to get reflected within your project. Godot can reimport a single file or multiple files.

var path = "res://assets/sprites/character.png"

This is a handy feature for assets that are frequently updated outside of Godot. You can easily keep your project up to date with the latest changes without manual reimporting.

We’ll continue building upon these examples in the next part of our tutorial, where we’ll explore more of the EditorFileSystem’s capabilities.

Understanding the concepts of Godot’s EditorFileSystem is just the beginning. Now let’s advance your knowledge with more complex operations and methods that will enhance your game development workflow. Allow me to guide you through some additional functionalities and their code examples.

One important aspect of resource management is keeping a clean project. For this, Godot’s EditorFileSystem allows you to remove unused resources:


This method helps in maintaining an efficient and uncluttered project by getting rid of the resources that aren’t linked to any part of your game anymore.

Another useful function is get_file_type(), which gives you the type of a certain file based on its extension or import metadata. This allows you to implement type-specific functionality within your scripting:

var file_type = fs.get_file_type("res://assets/characters/knight.png")
print(file_type) # Output might be something like "Texture"

Detecting when resources are updated is also incredibly important, especially when dealing with teams or external asset pipelines. Godot provides the signal resources_reimported to handle this:

fs.connect("resources_reimported", self, "_on_resources_reimported")

func _on_resources_reimported(paths):
    for path in paths:
        print("Resource reimported: " + path)

This approach can be crucial when you need to trigger additional scripts or tools once a resource is updated.

For those instances where you may want to refresh the entire project, Godot has you covered with the scan_sources() function. This is a more thorough version of the scan() method:


While scan() checks for changed files, scan_sources() performs a complete, deep scan of all source files. This can be useful after bulk changes to your project’s assets or scripts.

It’s equally important to handle the synchronization of imported files. Godot provides the method sync() for this purpose, ensuring that all imported files are in sync with their sources:

var success = fs.sync()
if success:
    print("Synchronization successful")
    print("Synchronization failed")

This method is synchronous and may take some time, as it will wait until the import process is finished before returning.

Lastly, for those more intricate workflows where you need to know the dependencies of a certain resource, the method get_dependencies() can list all files that a particular resource depends upon:

var dependencies = fs.get_dependencies("res://scenes/level.tscn")
for dependency in dependencies:
    print("Dependency: " + dependency)

Understanding resource dependencies is key to managing complex scenes and avoiding potential issues with missing assets.

As you can see, the EditorFileSystem class is a robust tool at your disposal for managing resources within Godot. By harnessing these functions, our approach to game development becomes more refined, strategic, and far less prone to errors. Stay tuned as we delve even deeper into Godot’s toolkit in upcoming tutorials, expanding your abilities and enhancing your game development prowess.

Godot’s EditorFileSystem class offers various utility functions that can significantly streamline the development process. Let’s continue exploring its capabilities with more code examples that you can integrate into your Godot projects.

Understanding how to update the filesystem is crucial. If you’ve manually deleted a file from the operating system or moved files around, you can call update_file() and update_directory() respectively to refresh the Editor’s awareness of these changes:

fs.update_file("res://old_path/to/file.tres", "res://new_path/to/file.tres")
fs.update_directory("res://old_path/to/directory", "res://new_path/to/directory")

These functions will ensure that the Editor’s internal state reflects the manual changes you’ve made, preventing any discrepancies.

If you need to programmatically find specific file types within your project, the get_file_type() method becomes remarkably handy. For instance, to find all scripts:

var directory = fs.get_filesystem()
for i in range(directory.get_file_count()):
    var file_path = directory.get_file(i)
    if fs.get_file_type(file_path) == "GDScript":
        print("GDScript file found: " + file_path)

With this snippet, you can automate the process of cataloguing scripts or other file types, which could help in batch operations like refactoring.

Overseeing the import process is also essential, especially when dealing with multiple assets. The get_imported_files() function returns a list of all imported files. You can do something like this:

var imported_files = fs.get_imported_files()
for file_path in imported_files:
    print("Imported file: " + file_path)

This method is invaluable for keeping tabs on all the assets in your project, especially after an extensive import session.

Handling the EditorFileSystem’s scanning progress can also be a useful part of your workflow. By connecting to the scan_begin and scan_end signals, you can get callbacks when scanning starts and ends:

fs.connect("scan_begin", self, "_on_scan_begin")
fs.connect("scan_end", self, "_on_scan_end")

func _on_scan_begin():
    print("Filesystem scanning started.")

func _on_scan_end():
    print("Filesystem scanning finished.")

Using these signals can help you provide feedback to the user, such as progress indicators or logs that scanning is in progress or complete.

For developers who need to keep track of when files and directories are moved within their project, Godot offers the moved() signal. This can be utilised to update custom tools or systems that rely on the precise location of resources:

fs.connect("moved", self, "_on_file_moved")

func _on_file_moved(from, to):
    print("Resource moved from " + from + " to " + to)

Lastly, Godot’s EditorFileSystem has an event for when a file is removed, the file_removed signal, giving you the ability to keep everything in sync:

fs.connect("file_removed", self, "_on_file_removed")

func _on_file_removed(file_path):
    print("File removed: " + file_path)

Optimizing your development practices with these functionalities of the EditorFileSystem class not only ensures a more effective workflow but also prepares you for scaling up your game development projects. Mastering these tools is what sets apart capable Godot developers from the rest. Keep experimenting with these methods to discover how you can further enhance your game’s development cycle.

Continuing Your Journey in Godot

Embarking on the journey of mastering Godot is an adventure filled with endless learning and creativity. After diving into the intricacies of the EditorFileSystem class, now is the perfect time to elevate your skills further. To continue shaping your path as a talented game developer, exploring new vistas of knowledge is key.

We encourage you to push your limits with our Godot Game Development Mini-Degree. This collection of comprehensive courses offers a structured path from the foundational pillars to more advanced concepts in building cross-platform games using the latest iteration of Godot. It’s a treasure trove of information that could transform you from a novice into a proficient developer, with a portfolio of real Godot projects to showcase your skills.

For those seeking a broader sphere, our repository of Godot courses spans various topics and proficiency levels. With over 250 supported courses, Zenva provides you with an abundance of learning material to ensure that your journey in game development continues smoothly, expand your expertise, or even explore new horizons in coding and AI.

Wherever you choose to go next on this pathway of learning, remember that it’s the skills you hone and the projects you create that will carve your future in the game development realm. Keep building, keep learning, and let your creativity flourish with Zenva.


Our exploration of Godot’s EditorFileSystem has uncovered just a fraction of what this powerful game engine has to offer. As game developers, harnessing the full potential of our tools is what helps us craft experiences that captivate and inspire. We believe that each lesson learned and each feature mastered brings you one step closer to realizing the games you’ve always dreamt of creating.

Embrace the thrill of building something extraordinary and continue your voyage with the Godot Game Development Mini-Degree. Let our structured courses be your guide to new achievements and milestones in your game development career. With Zenva, you’re not just learning – you’re becoming a part of a vibrant, creative community that’s shaping the future of gaming.

Python Blog Image

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