ColorRect in Godot – Complete Guide

Welcome to our tutorial on the ColorRect class in the upcoming Godot 4, an essential building block in creating vibrant visuals for your 2D games and UIs. Whether you’re someone just diving into the world of game development or a seasoned coder looking to add some pizzazz to a project, learning how to wield the power of ColorRect is a game-changer. Here, we’ll break down what it is, why it’s such a compelling feature to learn, and how you can harness it to enhance your own creations. So, let’s add some color to our developer palette together!

What is ColorRect?

ColorRect is a versatile class within the Godot engine specifically designed for displaying a simple rectangle filled with a solid color. Think of it as a canvas where your choice of color is the star of the show.

What is it for?

While it may seem simplistic, the ColorRect can be incredibly powerful when creating backgrounds, color overlays, and dynamic visual elements.

Why Should I Learn It?

Understanding how to implement a ColorRect effectively can quickly escalate your UI design from functional to fantastic. It’s a fundamental tool with a straightforward purpose that, when mastered, provides a foundation upon which more complex visual components can be built. Let’s jump into some examples and see it in action!

CTA Small Image

Creating a Simple ColorRect

Before we dive into the complex, let’s cover the basic creation of a ColorRect node.

extends Node2D

func _ready():
    var color_rect = # Create a new ColorRect instance
    color_rect.color = Color(1, 0, 0, 1) # Set the color to red
    color_rect.rect_size = Vector2(100, 100) # Set the size of the rectangle
    add_child(color_rect) # Add ColorRect to the current node

This code adds a 100×100 red square to our scene, perfectly illustrating the simplicity yet effectiveness of ColorRect.

Animating ColorRect

Animation is where ColorRect really shines. Let’s try changing the color over time.

extends ColorRect

# Called when the node enters the scene tree for the first time.
func _ready():
    modulate = Color(1, 1, 1, 0) # Start with a transparent ColorRect
    # Animate to a fully opaque blue over 2 seconds
    var animation = get_tree().create_animation('color_fade_in', 2)
    animation.track_set_path(0, "modulate")
    animation.track_insert_key(0, 0, Color(1, 1, 1, 0)) # Color key at time = 0s
    animation.track_insert_key(0, 2, Color(0, 0, 1, 1)) # Color key at time = 2s'color_fade_in')

Here we’ve applied a gentle fade-in effect, transitioning the ColorRect from transparent to a solid blue.

Responsive ColorRect

A responsive UI is key in game design. Let’s make our ColorRect adapt to the size of the game window.

extends ColorRect

func _ready():
    # Connect the signal emitted when the window is resized
    get_viewport().connect("size_changed", self, "_on_Window_resize")
func _on_Window_resize():
    # Make the ColorRect match the size of the game window
    rect_size = get_viewport().size

This snippet ensures that no matter the window size, the ColorRect will cover the entire area, making it ideal for backgrounds.

Interaction with ColorRect

Interactivity adds another level of engagement for players. Let us detect when our ColorRect has been clicked.

extends ColorRect

var clicked_color = Color(0, 1, 0, 1) # Define the color on click

func _ready():
    # Enable the ColorRect to receive input events
    mouse_filter = MOUSE_FILTER_STOP

func _input_event(_viewport, _event, _shape_idx):
    if _event is InputEventMouseButton and _event.pressed:
        color = clicked_color # Change color when clicked

Upon clicking the ColorRect, it will change to a bright green, offering clear visual feedback to the player.

In our next section, we’ll further explore the versatility of ColorRect by looking at more advanced examples. Stay with us as we continue to expand our toolkit, enabling dynamic and visually compelling game elements!Fantastic! As we delve deeper into the capabilities of the ColorRect class, our subsequent examples will help you explore its potential in creating sophisticated visual effects and functional game elements. Let’s dive in.

ColorRect as a Health Bar

Using ColorRect to create a dynamic health bar is a practical application. Here’s a quick example:

extends ColorRect

var max_health = 100
var current_health = max_health

func _ready():
    rect_min_size = Vector2(200, 20) # Set the size of the health bar

func take_damage(amount):
    current_health -= amount
    current_health = max(0, current_health) # Ensure health doesn't drop below 0

func update_health_bar():
    modulate = Color(1 - current_health / max_health, current_health / max_health, 0, 1)
    # Resize the ColorRect to represent current health
    rect_size.x = rect_min_size.x * (current_health / max_health)

Notice how the bar changes color and size based on the player’s health, providing immediate visual feedback.

Using ColorRect for Screen Transitions

Screen transitions enhance the player’s experience when changing scenes. Below is an example using a ColorRect to create a fade-out effect.

extends ColorRect

func fade_to_black(duration = 1.0, screen_after_fade = ""):
    var tween =
    tween.interpolate_property(self, "color", color, Color(0, 0, 0, 1), duration)
    tween.interpolate_callback(self, duration, "on_fade_to_black_complete", screen_after_fade)

func on_fade_to_black_complete(screen_after_fade):
    if screen_after_fade != "":

This method smoothly transitions the screen to black before changing to the specified scene.

Highlighting UI Elements

ColorRects can also highlight UI elements, such as button hovers or selections, dynamically.

extends ColorRect

func _ready():
    hide() # Start hidden
    # Connect signals from another UI element (e.g., Button)
    var button = get_node("Button")
    button.connect("mouse_entered", self, "_on_Button_mouse_entered")
    button.connect("mouse_exited", self, "_on_Button_mouse_exited")

func _on_Button_mouse_entered():
    rect_min_size = get_node("Button").rect_min_size
    rect_global_position = get_node("Button").rect_global_position

func _on_Button_mouse_exited():

Our ColorRect now responds to mouse events, indicating interactive UI elements with ease.

Creating a Gradient Background

The Godot Engine is rich with nodes that work in tandem. Let’s create a gradient background using ColorRect and GradientTexture.

extends ColorRect

func _ready():
    var gradient_texture =
    var gradient =
    gradient.colors = [Color(0.2, 0.3, 0.8, 1.0), Color(0.8, 0.9, 0.2, 1.0)]
    gradient_texture.gradient = gradient
    self.texture = gradient_texture
    self.stretch_mode = STRETCH_SCALE
    self.rect_min_size = Vector2(1280, 720) # Assuming HD resolution

The code above sets up a horizontal gradient from a cool blue to a warm yellow.

With these demonstrations, we’ve showcased just a fraction of what can be accomplished using the ColorRect node in Godot 4. We’ve created transitions, interactive elements, and even a fundamental UI component in a health bar. These snippets provide a solid foundation to build upon, combining Godot’s nodes and scripting power to craft visually engaging and responsive game features.

Our journey doesn’t stop here! We encourage you to experiment, tweak, and innovate with ColorRect, pushing the boundaries of what you can achieve in your game design. Keep exploring, and remember, the best way to learn is by doing. Create, break, fix, and create again. Happy coding!Great, let’s move forward and explore additional creative ways to utilize the ColorRect node. In the following snippets, we’ll tackle more complex design needs, and by the end, you’ll have a more extensive toolkit to make your UI and game elements truly shine.

ColorRect as a Cooldown Timer

Visual cooldown timers are key in informing players when an ability or item can be used again. Here’s how to create this using a ColorRect:

extends ColorRect

var cooldown_time = 5.0
var current_time = 0.0

func _ready():
    rect_min_size = Vector2(50, 50) # The size of the cooldown timer

func start_cooldown():
    current_time = cooldown_time
    # Update every frame

func _process(delta):
    current_time -= delta
    if current_time <= 0:
        hide() # Hide when cooldown is over
    # Update alpha based on the remaining cooldown time
    color.a = current_time / cooldown_time

Now you’ve got a cooldown timer that fades out as time progresses!

ColorRect for Modal Backgrounds

Modal backgrounds use semi-transparent ColorRects to focus attention on dialogue boxes or menus. Here’s an example of how to create one:

extends ColorRect

func show_modal_background():
    modulate = Color(0, 0, 0, 0.5) # Semi-transparent black
    rect_min_size = get_viewport_rect().size
    mouse_filter = MOUSE_FILTER_STOP # Block clicks to lower layers

Your modal background is ready to highlight specific UI elements while dimming the rest of the scene.

Dynamic Environment Effects

Let’s simulate a day-to-night cycle by altering the color of a fullscreen ColorRect:

extends ColorRect

var day_color = Color(0.3, 0.5, 1, 0.3) # Light blue for day
var night_color = Color(0, 0, 0.3, 0.75) # Dark blue for night
var transition_time = 5.0
var timer =

func _ready():
    rect_min_size = get_viewport().size
    modulate = day_color
    timer.wait_time = transition_time
    timer.one_shot = true
    timer.connect("timeout", self, "_on_Timer_timeout")

func _on_Timer_timeout():
    var new_color = modulate == day_color ? night_color : day_color
    modulate = new_color
    # Call the function again to create a continuous cycle

func timer_start():

Now you’ve added a dynamic environment effect that smoothly transitions between times of the day.

Interactive Color Picking

Let’s create an interactive color picker for customizing game characters or drawing applications:

extends ColorRect

func _ready():
    # Assume we have a series of ColorRects as child nodes named Color_1, Color_2, etc.
    for i in get_child_count():
        var color_rect = get_child(i)
        color_rect.connect("gui_input", self, "_on_ColorRect_mouse_entered")

func _on_ColorRect_mouse_entered(event, color_rect):
    if event is InputEventMouseButton and event.button_index == BUTTON_LEFT and event.pressed:
        emit_signal('color_selected', color_rect.color) # Emit a signal with the selected color

With these ColorRect children, users can select colors which might change the color of other game elements.

ColorRect for Custom Shaders

Finally, leverage ColorRect as a container for custom shaders, providing endless visual possibilities:

extends ColorRect

func _ready():
    # Set the size to cover the screen
    rect_min_size = get_viewport().size
    # Assume we have a shader material with a shader that simulates water
    var water_shader_material = load("res://water_shader_material.tres")
    self.material = water_shader_material

Utilizing shaders with ColorRect can result in visually stunning effects like water, fire, and more!

Each of these examples builds on the foundation we’ve established earlier, showing the extensibility of the ColorRect class. The more you experiment with these concepts, the more you’ll discover innovative ways to incorporate them into your projects. We hope these snippets inspire you to push the visual boundaries of your games and create something truly memorable. Keep exploring, keep developing, and, most importantly, keep enjoying the creative process!

Where to Go Next in Your Game Development Journey

Now that you’ve learned about the creative possibilities of the ColorRect class in Godot 4, you might be wondering how to continue improving your skills and knowledge in game development. The journey doesn’t end here! To keep honing your craft and to gain even more hands-on experience with Godot, we invite you to explore our Godot Game Development Mini-Degree. This comprehensive series of courses is tailored to guide you through the ins and outs of game creation using the Godot 4 engine.

Our Mini-Degree covers a wide array of essential topics, from using 2D and 3D assets to mastering GDScript and implementing intricate game mechanics. With projects at varying levels of complexity, you’ll have the opportunity to build a diverse portfolio of real-world Godot projects. It’s an ideal resource for both beginners and more experienced developers looking to expand their game development toolset.

In addition to the Mini-Degree, our extensive library of Godot courses provides a broad spectrum of learning materials. Check out our collection of Godot courses to find the perfect next step for your learning path. With Zenva, you can go from beginner to professional at your own pace, backed by a wealth of knowledge and support from our high-quality course offerings. So, why wait? Continue your journey with us, and let’s build some amazing games together!


Through the exploration of Godot’s ColorRect class, you’ve gained a new perspective on the power of simplicity in game development. The potential to create, animate, and interact with vibrant game elements is now at your fingertips, offering endless opportunities to enhance player experiences. Remember, each line of code you write takes you one step further in your journey as a game developer.

At Zenva, we’re passionate about providing you with the resources you need to turn your game development aspirations into reality. Whether you’re just starting or you’re looking to sharpen your existing skills, our Godot Game Development Mini-Degree is the perfect companion for your creative endeavors. Keep pushing the boundaries of what’s possible, and unlock your full potential with Zenva. Happy coding, and we can’t wait to see what you create next!

Python Blog Image

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