EditorFeatureProfile in Godot – Complete Guide

In the world of game development, efficiency and focus are key. Whether you’re a budding game developer diving into your first project or a seasoned professional working on a team, streamlining your work environment can significantly enhance productivity. This is where Godot Engine’s EditorFeatureProfile class in Godot 4 comes into play. It’s an incredibly powerful tool for customizing and simplifying the Godot editor interface to match your specific workflow needs.

What Is EditorFeatureProfile?

At its core, the EditorFeatureProfile class is a feature of Godot Engine that enables you to selectively disable certain parts of the editor. By doing so, you create an environment tailored to the tasks at hand. Think of it as a set of switches, where you can turn on or off different components of the editor, based on what is necessary for your current role or task.

What Is It For?

The EditorFeatureProfile class provides a way to declutter the Godot editor by hiding features that aren’t needed. This can be extremely beneficial in educational settings, helping new developers focus on relevant areas without feeling overwhelmed. It’s also valuable for teamwork, allowing for the creation of profiles that show only the tools that a user like an artist or level designer might need, avoiding confusion and accidental edits outside their domain.

Why Should I Learn It?

Learning to use the EditorFeatureProfile effectively can do wonders for your game development workflow. Customizing your editor to fit your role not only improves focus on your task but also reduces the chance for errors by hiding unnecessary features that you might otherwise accidentally interact with. This level of customization can be particularly helpful when teaching others or when you want to create a safe, streamlined work environment for your team.

CTA Small Image

Creating Your First EditorFeatureProfile

To get started with EditorFeatureProfile in Godot 4, you initially need to create a new instance. This is straightforward and is initiated in the script where you plan to customize the editor. Creating a new profile can be done with a single line of code:

var feature_profile = EditorFeatureProfile.new()

Once you’ve created an instance of EditorFeatureProfile, the next step is to start configuring it by disabling features. Below is an example of how to disable 3D editing tools:

feature_profile.set_disable_class("SpatialEditorPlugin", true)

This effectively hides all 3D editing tools, perfect for those working exclusively on 2D games.

Customizing Editor Panels

If you’re working with 2D assets, you may want to remove any distractions arising from 3D nodes. Here’s how you could hide the entire set of 3D nodes from the node creation dialog:

feature_profile.set_disable_class_editor("MeshInstance", true)
feature_profile.set_disable_class_editor("CPUParticles", true)
feature_profile.set_disable_class_editor("DirectionalLight", true)

This will ensure that when you, or any member of your team, go to create a new node, 3D options such as MeshInstance, CPUParticles, and DirectionalLight will not appear, keeping focus squarely on 2D development.

Streamlining the Inspector

The inspector can often become cluttered with many properties, some of which might not be relevant to your current work. To simplify the inspector, you can disable entire categories or individual properties:

feature_profile.set_disable_property("Node", "pause_mode", true)
feature_profile.set_disable_property("Node2D", "z_as_relative", true)

In this example, we have hidden the ‘pause_mode’ property for all Nodes and the ‘z_as_relative’ property specifically on Node2D objects. This will make the inspector cleaner and more manageable.

Configuring the Scene Tree

The scene tree is a central component of the Godot editor, displaying the hierarchy of nodes in the current scene. To prevent certain node types from showing up in the scene tree, you might use:

feature_profile.set_disable_class_scene_tree("CollisionShape", true)
feature_profile.set_disable_class_scene_tree("Area", true)

With the above code, CollisionShape and Area nodes will now be hidden from the scene tree. This can be utilized to focus on the visual aspects of your game during design stages.

Now that you’ve learned how to create and customize an EditorFeatureProfile, the next step is to integrate it into your Godot editor. We’ll explore this in the following sections, teaching you how to apply your custom profile and share it with your team.

Integrating an EditorFeatureProfile into your Godot editor setup is your next milestone. Let’s go through how to apply your custom profile and ensure it shapes your development environment according to your specifications.

To begin using your new EditorFeatureProfile, you must apply it to the editor. The following code snippet illustrates how you can achieve this:

EditorInterface editor_interface = get_editor_interface()

This will apply your custom feature profile to the current editor session, instantly updating the interface to reflect your configurations.

However, you might want to switch between different profiles based on what you’re working on. For this, you can write a function to switch profiles on the fly:

func switch_feature_profile(profile_name: String):
    var profiles = {
        "2D": preload("res://profiles/2D_profile.tres"),
        "Scripting": preload("res://profiles/Scripting_profile.tres")
    var profile = profiles[profile_name]
    if profile:

In this example, calling switch_feature_profile("2D") would switch the current editor to use the 2D profile, predefined and saved as a resource in your Godot project.

Suppose you want to save your EditorFeatureProfile to reuse it later or share it with your team. In that case, you can save it as a resource file:

ResourceSaver.save("res://my_feature_profile.tres", feature_profile)

With the profile saved, anyone on your team can load and apply it quickly:

var profile = ResourceLoader.load("res://my_feature_profile.tres")

By encapsulating these operations in scripts or tool-scripts, you could create custom buttons or menu options within Godot that let developers in your team switch profiles according to their current task, enhancing workflow efficiency.

And what if you want to restore specific features temporarily without switching the entire profile? It’s possible. Here’s how to re-enable a previously disabled feature using scripts:

feature_profile.set_disable_class("SpatialEditorPlugin", false)

Lastly, to ensure that your editor layout stays consistent between sessions, you might want to load a default profile when the editor starts. You could use the EditorPlugin‘s _enter_tree() function for this:

func _enter_tree():
    var default_profile = preload("res://profiles/default_feature_profile.tres")

This technique guarantees that no matter which developer opens the project, they start with a common, predefined editor setup tailored to your game development needs.

With these powerful examples of what you can achieve using EditorFeatureProfile in Godot 4, your game development process can become more focused and streamlined than ever. Try applying these techniques to your project, and see how they can improve your productivity and team collaboration.

Let’s delve deeper into utilizing the EditorFeatureProfile class with additional examples that cater to various aspects of game development and enhance your custom editor experience.

Imagine you’re working on a large project with many assets, and you want to simplify asset management. You could disable the creation of certain resource types that aren’t relevant to your current stage of development. Here’s an example:

feature_profile.set_disable_class_resource("Animation", true)
feature_profile.set_disable_class_resource("Shader", true)

These lines disable the ability to create new Animation and Shader resources directly from the editor, helping to avoid clutter and accidental additions.

For those focusing on scripting, the script editor can also be customized. Suppose you rarely use the built-in help or search functionality; you might opt to hide these elements:

feature_profile.set_disable_script_editor_feature(EditorFeatureProfile.SCRIPT_EDITOR_FEATURE_HELP, true)
feature_profile.set_disable_script_editor_feature(EditorFeatureProfile.SCRIPT_EDITOR_FEATURE_SEARCH, true)

Alternatively, you may want to streamline your UI by hiding docks you do not regularly use:

feature_profile.set_disable_dock_slot(EditorFeatureProfile.DOCK_SLOT_LEFT_UL, true)
feature_profile.set_disable_dock_slot(EditorFeatureProfile.DOCK_SLOT_RIGHT_BL, true)

This removes the upper left and bottom right dock slots from your view, creating a cleaner workspace tailored to your needs.

What about when you want to limit interaction with certain nodes to reduce the risk of unintended changes? For example, if you want to lock down transform properties of your UI elements, you can disable their modification:

feature_profile.set_read_only_property("Control", "rect_scale", true)
feature_profile.set_read_only_property("Control", "rect_position", true)

With the above code, anyone editing UI elements in the scene will find that ‘rect_scale’ and ‘rect_position’ properties cannot be altered, preserving the intended layout and design.

Now consider that you want to foster a focus on visual scripting. You can tailor the editor to favor this mode of development:

feature_profile.set_disable_editor_feature(EditorFeatureProfile.EDITOR_FEATURE_VISUAL_SCRIPT, false)
feature_profile.set_disable_editor_feature(EditorFeatureProfile.EDITOR_FEATURE_SCRIPT, true)

This configuration enables the Visual Script editor while disabling the text-based script editor, steering the development environment towards visual scripting.

The beauty of EditorFeatureProfile extends beyond static configurations. You can make dynamic adjustments based on user roles or project phases. For example, here’s how you might enable and disable features based on a developer’s role:

var role = "artist"  # This could be dynamically determined via a user system or similar
if role == "artist":
    feature_profile.set_disable_class("ScriptEditor", true)
elif role == "programmer":
    feature_profile.set_disable_class("CanvasItemEditorPlugin", true)

In this scenario, an artist’s profile would disable the script editor, while a programmer’s profile would disable 2D canvas editing tools, focusing each on their respective tasks.

Lastly, remember that any changes made via EditorFeatureProfile take effect immediately and will be in force for the rest of the editor session or until you change the profile again. This ensures a dynamic, adaptable workflow that can be continuously optimized for evolving project requirements and development stages.

With these additional examples, you have a broader understanding of how to leverage the full potential of the EditorFeatureProfile class. Tailoring the Godot editor to suit specific development needs can significantly improve efficiency, reduce distractions, and create a focused environment for everyone involved in the project. Dive in and experiment with these features to fine-tune your own Godot editor experience!

Continuing Your Game Development Journey

Delving into EditorFeatureProfile in Godot 4 is just the beginning of what you can achieve in this powerful game engine. To continue honing your skills and building your knowledge, we warmly encourage you to explore our Godot Game Development Mini-Degree. This Mini-Degree is designed to take you through the ins and outs of Godot, from the essential basics to more advanced features, equipping you with the expertise to craft engaging, interactive games all by yourself.

By engaging with our carefully curated curriculum, you’ll learn to create various game types, delve into 2D and 3D game development, and even unlock the secrets to devising compelling gameplay mechanics. Regardless of where you are on your coding journey, our courses cater to all expertise levels and allow you to learn at your own pace. As you progress, you’ll be piecing together a professional portfolio that showcases your capacity to design and develop in the Godot engine.

For those who are eager to expand their game development toolbox even further, we also offer a broader range of Godot courses. Whether you’re aspiring to become a game developer or looking to level up your current skills, our courses are tailored to help you achieve your goals. Start with us at Zenva, and step into a world of interactive storytelling, compelling game mechanics, and immersive game environments, all while building a career in game development.


In conclusion, mastering the EditorFeatureProfile class in Godot 4 is a game-changer for developers seeking a more streamlined, focused, and custom-tailored game development experience. It’s an empowering tool that aligns the editor with your unique workflow, allowing you to enhance productivity and reduce distractions. By applying the principles and examples we’ve discussed, you’re already on your way to crafting a more efficient and enjoyable game creation process.

Remember that at Zenva Academy, we are dedicated to supporting you through each step of your game development journey. Whether you’re refining your current project or starting anew, our Godot Game Development Mini-Degree offers you the comprehensive guidance needed to transform your ideas into reality. Join us and a community of passionate developers, and let’s build amazing games together—one line of code at a time.

Python Blog Image

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