Separator in Godot – Complete Guide

Welcome to this tutorial where we delve into the intricacies of the Separator class in Godot 4. Creating a well-structured and visually appealing user interface (UI) is an essential part of game development, and understanding the tools at your disposal is key. In this article, we’ll explore what a Separator is, what it’s used for, and why acquiring knowledge about it is crucial for your development journey. Let’s take a step towards mastering UI elements in Godot 4 and see how separators can enhance your game’s design!

What Is a Separator in Godot 4?

A Separator in Godot 4 is an abstract base class represented visually by either a horizontal or vertical line, designed to create visual distinction between UI elements. While simple in concept, separators play a vital role in organizing content and creating clean, easy-to-navigate interfaces.

What Is It For?

Separators are utilized in UI design to:

  • Improve readability by grouping related elements together while keeping them distinct from others.
  • Provide a visual cue for the user’s eye to navigate the interface efficiently.

Why Should I Learn About Separators?

Knowledge of separators will imbue your UI designs with a professional touch and seamless user experience. As game developers, we strive for not only functionality but also an aesthetic appeal, making separators a subtle yet powerful tool in our toolkit. Learning about separators is a step toward creating intuitive and engaging interfaces that keep players immersed in the game world.

CTA Small Image

Creating a Horizontal Separator in Godot 4

To begin with, let’s add a horizontal separator to our interface. This is particularly useful when you want to divide aspects of your UI such as separating a toolbar from the rest of the application, or different sections of a menu.

var h_separator =

This code snippet creates a new horizontal separator and adds it as a child to the current node, which places it in the UI. You can adjust its position and size using the Rect properties.

h_separator.rect_min_size = Vector2(400, 5)
h_separator.rect_position = Vector2(100, 100)

Creating a Vertical Separator in Godot 4

Similarly, if you need to split elements side by side, a vertical separator comes in handy. For example, in a settings menu where you might want to separate different categories of settings:

var v_separator =

Again, you can customize the size and positioning to fit your UI design:

v_separator.rect_min_size = Vector2(5, 300)
v_separator.rect_position = Vector2(150, 150)

Styling Separators

Godot 4 allows you to style your separators to match the visual theme of your game. You can set a custom style for your separators using StyleBoxFlat:

var style =
style.bg_color = Color(1, 0, 0)  # Red color
h_separator.custom_styles["separator"] = style

For a vertical separator, you would similarly create a StyleBoxFlat instance and assign it:

var v_style =
v_style.bg_color = Color(0, 1, 0)  # Green color
v_separator.custom_styles["separator"] = v_style

Adding Interactivity

While separators are generally static, Godot’s flexibility allows you to incorporate them into interactive UI elements. For instance, you may want a separator that changes style when a certain game event occurs:

func update_separator_color(new_color: Color):
    var dynamic_style =
    dynamic_style.bg_color = new_color
    h_separator.custom_styles["separator"] = dynamic_style

By changing the separator’s style dynamically through script, you can indicate gameplay states, highlight menu selections, or simply add a cosmetic flourish to your game’s interface.

Now that we are familiar with creating and styling separators in Godot 4, let’s continue to reinforce our knowledge with more practical examples. Understanding the versatility of separators can really make a difference in your UI work.

For starters, you might want to animate your separators to draw attention to a particular UI element or show an active state. Here’s an example of animating a horizontal separator:

var tween =
tween.interpolate_property(h_separator, "rect_min_size", h_separator.rect_min_size, Vector2(600, 5), 1, Tween.TRANS_LINEAR, Tween.EASE_IN_OUT)

This code will animate the width of the horizontal separator from its current size to 600 pixels wide over the course of 1 second. The ‘Tween’ node is a powerful tool that can be used to interpolate properties of practically any object.

The following example shows how you can bind a separator’s visibility to a button press, toggling it on and off:

func _on_button_toggle_pressed():
    h_separator.visible = !h_separator.visible

If you have multiple separators and want to manage them together, you can place them in a group and iterate over them with ease:


func hide_all_separators():
    for separator in get_tree().get_nodes_in_group("separators"):
        separator.visible = false

This will hide every separator you have added to the “separators” group. Groups in Godot are a very convenient way to manage multiple nodes of the same type or which require similar actions.

Another common feature in UI design is to ensure elements adapt to screen resizing. Below, we’ll make use of the ‘size_flags’ property to help our separator scale properly when the window size changes:

h_separator.size_flags_horizontal = Control.SIZE_EXPAND_FILL

Now the horizontal separator will expand to fill the available space, adapting to changes in the window’s width. For a vertical separator, this would be ‘size_flags_vertical’ accordingly:

v_separator.size_flags_vertical = Control.SIZE_EXPAND_FILL

Finally, Godot’s signals can also be employed with separators. Here’s a way to use signals to print a message every time the scene tree changes, which would include adding or moving a separator:

func _ready():
    get_tree().connect("tree_changed", self, "_on_tree_changed")

func _on_tree_changed():
    print("The scene tree has changed!")

When you add or move a separator node, ‘_on_tree_changed’ will be called and execute its code, in this case, printing a message to the console.

These examples should give you a solid foundation for incorporating separators in your Godot 4 projects with ease, enhancing UI clarity and design. Remember, often it’s the subtle details like separators that can greatly enhance the professionalism and polish of your game’s interface.

Let’s delve deeper into the practical applications and advanced techniques to leverage separators in our UI design within Godot 4. These examples will continue to reinforce our understanding and showcase how separators can transform a user interface from good to excellent.

Consider you have a dialog box where options are listed vertically. To better differentiate these options from each other, you might use alternating background colors with separators:

func create_option_list():
    for i in range(10):  # Let's say we have 10 options
        var option_label =
        option_label.text = "Option " + str(i + 1)

        var sep = i % 2 == 0 ? :
        sep.rect_min_size = Vector2(300, 2)

Now, separators will be inserted between each of the label options. This alternating approach helps users distinguish between different interactive elements.

What if we want our separators to be more than just visual elements? We can associate actions with them—like expanding a section of our UI when clicked:

var expandable_section =

func _ready():
    expandable_section.connect("mouse_entered", self, "_on_Separator_mouse_entered")
    expandable_section.connect("mouse_exited", self, "_on_Separator_mouse_exited")

func _on_Separator_mouse_entered():
    expandable_section.rect_min_size.y *= 2  # Expand the separator

func _on_Separator_mouse_exited():
    expandable_section.rect_min_size.y /= 2  # Shrink the separator back

This example demonstrates how to use signals like ‘mouse_entered’ and ‘mouse_exited’ to modify the separator’s appearance, simulating an interactive element.

We might also want to use separators to create a collapsible sidebar, which can be a common feature in strategy games or applications with complex UIs:

var sidebar =
var sidebar_toggle_button =

sidebar_toggle_button.text = "Toggle Sidebar"

sidebar_toggle_button.connect("pressed", self, "_on_toggle_button_pressed")

func _on_toggle_button_pressed():
    sidebar.visible = !sidebar.visible  # This toggles the visibility of the sidebar

Here, the separator acts as a button to collapse or expand a sidebar. When structured correctly, separators can be an integral part of your UI’s dynamic layout.

For more nuanced control over the appearance and animations of separators, we can delve into shaders. Here is a simple shader to create a pulsing effect on a Separator:

shader_type canvas_item;

void fragment() {
    float amplitude = 0.5 + sin(TIME) * 0.5;
    COLOR = vec4(1.0, 1.0, 1.0, amplitude);

To apply this shader to a separator, simply create a new ShaderMaterial, assign this code to it, and then apply it to the separator’s ‘material’ property:

var pulsing_separator =
var shader_mat =
shader_mat.shader.code = shader_code  # The shader code from above
pulsing_separator.material = shader_mat

With this effect, your separators can pulsate, thus attracting attention or indicating interactivity. Keep in mind this introduction to shaders is just scratching the surface—Godot’s shader language is highly capable, offering myriad possibilities to enhance your UI with rich visual effects.

These code examples exemplify not only the basic usage of separators in Godot 4 but also some more advanced and creative implementations. Utilizing these versatile UI elements effectively can greatly enhance the player’s experience and increase the usability of your game or application.

Where to Go Next in Your Godot Learning Journey

With the fundamentals of separators in Godot 4 under your belt, your journey to mastering game development is well underway. As you continue to build your skills, consider taking the next step with our Godot Game Development Mini-Degree. This comprehensive program offers a rich collection of courses that will further your understanding of game development using the Godot 4 engine. From creating immersive 2D and 3D games to mastering gameplay mechanics, our Mini-Degree is designed to arm you with the tools and knowledge needed to bring your game ideas to life.

Whether you’re just beginning or looking to polish your existing skills, our curriculum caters to all learning stages. You’ll enjoy the flexibility to pace your studies as you see fit, diving deep into topics that pique your interest and challenging yourself with interactive lessons and coding projects.

For a complete overview of what we offer in the realm of Godot, you’re invited to browse our broader selection of Godot courses. With Zenva, you can transform from a beginner into a professional game developer, ready to tackle challenging projects and take the gaming world by storm. Seize the opportunity to learn, create, and perhaps even redefine the limits of independent game development.


In wrapping up this tutorial, we hope the power of separators in Godot 4 has become clear to you. Effective UI design is a critical component of game development, and mastering the use of separators is one step among many towards creating a satisfying player experience. As you continue your voyages in game creation, leverage these insights to give your projects the polished look and intuitive feel they deserve.

Remember, every great game developer started somewhere, and with Zenva, you’re never alone on your learning path. Keep building your Godot knowledge with our Godot Game Development Mini-Degree and turn your game development aspirations into achievements. Forge ahead, keep creating, and let’s shape the future of gaming together!

Python Blog Image

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