StyleBox in Godot – Complete Guide

Welcome to our tutorial on the StyleBox class in Godot 4. As you delve into creating user interfaces (UIs) for your games or applications, mastering the StyleBox class will enable you to stylize UI elements with flair. This versatile tool is a cornerstone in crafting visually appealing and intuitive interfaces. So, sharpen your skills and get ready to elevate your UI game!

What is StyleBox?

StyleBox is a powerful abstract base class within the Godot Engine used to create decorated boxes around UI elements. It’s incredibly versatile, serving as the foundation for user interface components like panels, buttons, and input fields, as well as handling more advanced features like transparency masks for touch or click input.

What is StyleBox Used For?

In the world of UI development, StyleBox is the artist’s brush, allowing developers to define the look and feel of interactive elements. With it, you can adjust margins, draw backgrounds, and set the overall tone for user interaction. If you were creating a menu system for a game, using StyleBox could help you visually distinguish between menu options with different states like normal, hover, or clicked.

Why Should I Learn StyleBox?

Understanding how to implement StyleBox in your Godot projects is crucial for generating a polished and professional UI. Good UI design not only makes your application look good, but it also enhances user experience by providing clear and responsive navigation. As a game developer or UI designer, learning to wield StyleBox effectively can set your work apart. Furthermore, the knowledge you gain can be transferred to other UI design tasks, making it a skill well worth mastering.

CTA Small Image

Creating a Basic StyleBox

To begin, let’s see how to create a simple StyleBox that can be applied to a UI element. Godot’s Inspector provides a straightforward interface to modify StyleBoxes, but you can also create and manipulate them through GDScript. Here’s how you add a StyleBox to a Button through code:

var button =
var style =
style.bg_color = Color(0.2, 0.7, 0.3)
style.border_color = Color(0.1, 0.5, 0.2)
style.border_width_top = 2
style.border_width_bottom = 2
style.border_width_left = 2
style.border_width_right = 2
button.add_stylebox_override("normal", style)

This block of code creates a simple green button with a slightly darker green border. The add_stylebox_override function changes the button’s normal state appearance by applying the newly-created StyleBoxFlat.

Manipulating Corners and Shadows

Now let’s embellish our StyleBox by manipulating its corners and adding a shadow for a more three-dimensional look. The following example builds upon the previous one:

style.corner_radius_top_left = 10
style.corner_radius_top_right = 10
style.corner_radius_bottom_right = 10
style.corner_radius_bottom_left = 10

style.shadow_color = Color(0, 0, 0, 0.5)
style.shadow_size = 4
style.shadow_offset = Vector2(3, 3)

button.add_stylebox_override("normal", style)

Here, we’ve introduced rounded corners and a shadow that casts down and to the right. The corner_radius properties shape the corners, and shadow_* properties handle the shadow’s appearance, providing a sense of depth to our UI button.

Responsive Hover and Click States

An interactive UI element should visually respond to user actions. Let’s define hover and pressed states for our button:

var hover_style = style.duplicate()
hover_style.bg_color = Color(0.3, 0.8, 0.4)
hover_style.shadow_size = 6
hover_style.shadow_offset = Vector2(2, 2)

var pressed_style = style.duplicate()
pressed_style.bg_color = Color(0.1, 0.6, 0.2)
pressed_style.shadow_size = 2
pressed_style.shadow_offset = Vector2(1, 1)

button.add_stylebox_override("hover", hover_style)
button.add_stylebox_override("pressed", pressed_style)

In this snippet, we duplicated our original style and modified it for the hover and pressed states. A lighter color and larger shadow for hover, and a darker color with a smaller shadow for pressed, signal interaction to the user.

Styling with Texture

Sometimes, a flat style isn’t enough, and you might want to use textures for your UI elements. Here’s how you could apply a texture to a StyleBoxTexture respective to a button:

var texture_style =
texture_style.texture = preload("res://path_to_your_texture.png")
texture_style.margin_left = 4
texture_style.margin_top = 4
texture_style.margin_right = 4
texture_style.margin_bottom = 4

button.add_stylebox_override("normal", texture_style)

This code applies a texture to a new style box, ensuring it has some margins so the texture doesn’t stretch to the very edge of the button. Using textures can give your UI a unique visual flair that sets it apart from applications with more standard designs.

These examples provide a foundation on which you can build and customize your UI to match your game’s style. In the following sections, we will continue to explore how StyleBox can be used to enhance other UI components.

Animating StyleBox Properties

Making UI elements dynamic can vastly improve the user experience. In Godot, you can animate the properties of a StyleBox to create engaging effects:

var animation =
animation.track_set_path(0, "StyleBoxFlat:bg_color")
animation.track_insert_key(0, 0.0, Color(0.2, 0.7, 0.3))
animation.track_insert_key(0, 1.0, Color(1.0, 0.7, 0.3))

var animation_player =
animation_player.add_animation("change_color", animation)"change_color")

In this example, we animate the bg_color property of a StyleBoxFlat over a duration of 1 second, transitioning from green to orange. An AnimationPlayer node is used to play the animation.

Custom Drawing with StyleBoxCustom

If the existing StyleBox types aren’t enough, Godot provides StyleBoxCustom which allows for custom drawing code. This is especially useful when you need to draw complex shapes or patterns that can’t be achieved through standard properties:

extends StyleBoxCustom

func _draw():
    draw_rect(Rect2(Vector2(0, 0), Vector2(100, 50)), Color(0.5, 0.5, 0.7), true)
    draw_text(get_font("font"), Vector2(10, 15), "Custom StyleBox", Color(1, 1, 1))

In this minimal custom style, we directly draw a rectangle and text onto the UI element, providing full control over how it’s rendered.

Using StyleBox for Containers

Besides individual elements like buttons, StyleBox can be applied to containers to give them a unique look. Here’s how you could style a Panel container:

var panel =
var panel_style =
panel_style.bg_color = Color(0.1, 0.1, 0.1)
panel_style.border_color = Color(0.7, 0.7, 0.7)
panel_style.border_width_all = 3
panel.add_stylebox_override("panel", panel_style)

This sets a dark background with a light border for your Panel, assuming a container or background role in your UI.

Theming with StyleBox

For consistently styled UIs across your project, you can use themes. Let’s see how we can create a Theme resource and apply a StyleBox style to multiple elements:

var theme =
var default_button_style =
default_button_style.bg_color = Color(0.25, 0.25, 0.25)
default_button_style.border_width_all = 2

theme.set_stylebox("normal", "Button", default_button_style)

var button1 =

var button2 =


With this theme, all Buttons in your project can share the same design by referencing the same Theme resource. This ensures consistency and simplifies the design process across multiple UI elements.

Through these examples, you’ve seen how Godot’s StyleBox can be used to enhance UI components and how its properties can be animated, customized, and themed. We encourage you to experiment and implement StyleBoxes in your UI designs. Remember, a well-designed interface is key to an engaging user experience. Dive into the StyleBox class with confidence, and watch as your UIs come to life!

Let’s explore how to create nine-patch StyleBox textures, which are commonly used in UI to create scalable elements that maintain the integrity of borders and corners while the center region stretches:

var nine_patch_style =
nine_patch_style.texture = preload("res://path_to_your_nine_patch_texture.png")
nine_patch_style.set_patch_margin(Margin.LEFT, 6)
nine_patch_style.set_patch_margin(Margin.TOP, 6)
nine_patch_style.set_patch_margin(Margin.RIGHT, 6)
nine_patch_style.set_patch_margin(Margin.BOTTOM, 6)

var nine_patch_button =
nine_patch_button.add_stylebox_override("normal", nine_patch_style)

This snippet demonstrates the creation of a nine-patch StyleBox for a button, ensuring that your texture scales beautifully no matter the size of the button.

Now, consider using StyleBoxes to create a tooltip with a pointer:

var tooltip_style =
tooltip_style.bg_color = Color(0.2, 0.2, 0.2)
tooltip_style.border_width_all = 2
tooltip_style.border_color = Color(0.8, 0.8, 0.8)
tooltip_style.set_content_margin(Margin.TOP, 10)
tooltip_style.set_content_margin(Margin.LEFT, 10)
tooltip_style.set_content_margin(Margin.RIGHT, 10)
tooltip_style.set_content_margin(Margin.BOTTOM, 20) # More bottom margin for the pointer

func draw_tooltip_pointer(tooltip_style):
    tooltip_style.draw(get_canvas_item(), Rect2(Vector2(0, 0), size))
    var pointer_tri = Vector2Array()
    pointer_tri.push_back(Vector2(size.x / 2 - 10, size.y - 10)) # Left point
    pointer_tri.push_back(Vector2(size.x / 2, size.y))             # Tip of the pointer
    pointer_tri.push_back(Vector2(size.x / 2 + 10, size.y - 10))   # Right point
    draw_polygon(pointer_tri, [tooltip_style.border_color, tooltip_style.border_color, tooltip_style.border_color])

var tooltip = # A control node for our tooltip
tooltip.set_size(Vector2(200, 100)) # Specify the size of the tooltip
tooltip.set_custom_minimum_size(Vector2(200, 100)) # Set a minimum size so it doesn't shrink
tooltip.connect("draw", self, "draw_tooltip_pointer", [tooltip_style])

The tooltip StyleBox is designed with a larger bottom margin to make space for the pointer, which is drawn as a separate polygon onto the Control node. This adds a custom touch to our UI element.

Besides static UI elements, you can also animate the properties of StyleBoxes to respond to user interaction. Let’s animate a button to change its border color when focused:

var focus_animation =
focus_animation.track_set_path(0, "border_color")
focus_animation.track_insert_key(0, 0.0, Color(1, 1, 1))
focus_animation.track_insert_key(0, 0.5, Color(0, 1, 0))
focus_animation.track_set_loop(0, true)

var button_focused_style = button.default_style.duplicate()
var focus_animation_player =
focus_animation_player.add_animation("focus_animation", focus_animation)

button_focused_style.set_stylebox("focus", button_focused_style)
button_focused_style.connect("focus_entered", focus_animation_player, "play", ["focus_animation"])
button_focused_style.connect("focus_exited", focus_animation_player, "stop", ["focus_animation"])

This animation smoothly transitions the button’s border color from white to green and back, indicating focus. The animation loops for as long as the button remains focused.

Lastly, we’ll look at how overriding StyleBox properties can introduce new states to our UI elements. For instance, to add a disabled state to buttons:

var disabled_style = default_button_style.duplicate() # Base it off the default button style
disabled_style.bg_color = Color(0.4, 0.4, 0.4) # A dull background color
disabled_style.border_color = Color(0.3, 0.3, 0.3) # A darker border color

button.add_stylebox_override("disabled", disabled_style)
button.set_disabled(true) # This will use the disabled style we just set up

This demonstrates setting the disabled state with a darker, duller color scheme, clearly indicating that the button is not interactive.

These examples show the flexibility and power of Godot’s StyleBox in designing responsive and lively UI elements. From scalable textures to custom drawn elements and dynamic animations, StyleBox lets you create a UI that’s both beautiful and behaviorally rich, enhancing the overall user experience. Go ahead and experiment with these examples, and see how you can use StyleBox to bring your UI designs to life in Godot.

Continuing Your Godot Journey

As you’ve taken your first steps into the world of UI design with Godot’s StyleBox, we at Zenva encourage you to keep pushing the boundaries of what you can create. The journey of learning and development never stops, and if you’re ready to dive deeper into game creation with Godot 4, our Godot Game Development Mini-Degree is the perfect next step.

Offering a comprehensive array of project-based courses, this Mini-Degree covers a wealth of topics from 2D and 3D game development to complex gameplay mechanics. Whether you are a beginner looking to solidify your fundamentals or an experienced developer aiming to expand your skill set, there’s something in this curriculum for you.

Additionally, for a broader range of content, explore our full selection of Godot courses. They are designed to adapt to your learning pace while helping you build a robust portfolio of projects. Embrace the freedom to learn and the ability to turn your game development dreams into reality with Zenva.


Your journey through the realms of Godot’s StyleBox class showcases just how much control and creativity you can exert over your UI design. Remember, a well-crafted UI is not just about looks; it’s about providing a seamless and enjoyable experience for your players. As you continue to harness the power of Godot 4, let each project refine your skills and expand your ability to communicate through engaging interfaces.

We at Zenva are excited to see the unique and captivating UI designs you’ll develop next. Should you desire to deepen your knowledge or explore new territories in Godot game development, our Godot Game Development Mini-Degree awaits you with open arms. So, leap into your next learning adventure, and let us help you become the game developer you aspire to be!

Python Blog Image

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