ScrollContainer in Godot – Complete Guide

When developing games or applications with a lot of content, it’s common to run into the issue of having more information than the screen can display. The user interface (UI) needs to be intuitive and accessible, and one of the key UI components that help achieve this is the scroll container. A scroll container lets users navigate through extra content by scrolling vertically or horizontally. In this tutorial, we’ll dive into the ScrollContainer class in Godot 4, which can significantly enhance your UI by providing scrollbars to an overflowing child control when needed.

What Is ScrollContainer?

class ScrollContainer extends Container

ScrollContainer is a class in Godot 4 designed to house a Control node and equip it with automatically generated scrollbars. If the content within this container exceeds the container’s dimensions, scrollbars will appear, allowing the user to scroll to reveal the hidden content. It’s a crucial tool in UI design for managing large amounts of data or lengthy interfaces in a limited space.

What Is It For?

The ScrollContainer makes it possible to create interfaces that can handle various amounts of content gracefully. Whether you’re developing an extensive in-game inventory, a dialogue system, or even a settings menu, the ScrollContainer can enhance the user experience by providing a clean and navigable interface.

Why Should I Learn It?

Understanding how to implement and manage a ScrollContainer is essential for good UI/UX design in Godot. By mastering this tool, you’ll be able to:

– Create dynamic user interfaces that adapt to their content.
– Ensure your application or game is accessible, regardless of screen resolution or aspect ratio.
– Improve the overall aesthetic and professionalism of your projects.

Scroll containers are not only practical but also highly customizable, so learning this skill will open up a new level of creativity in your UI work.

CTA Small Image

Adding ScrollContainer to Your Scene

The first step in using a ScrollContainer is to add it to your scene. You can do this through the Godot editor by creating a new node. Here’s a simple way to set it up in GDScript:

var scroll_container =

This script creates a new ScrollContainer and adds it as a child to the current node. Now that the container is in the scene, it’s time to add content to it. Remember that the ScrollContainer will only display scrollbars when its contents exceed its own size.

Configuring the Size and Scrollbars

Once you have your ScrollContainer in the scene, you’ll need to configure its size and determine when the scrollbars should appear. You can set the size of the ScrollContainer directly or through the editor. Here’s how to do it in code:

scroll_container.rect_min_size = Vector2(300, 400)

To control the scrollbar’s visibility and behavior, you can use the following properties:

– `v_scroll` and `h_scroll`: Visibility of the vertical and horizontal scrollbars, respectively.
– `scroll_deadzone`: The deadzone size for the scrollbar to become visible when the user attempts to scroll.

Here’s an example of setting a vertical scrollbar to always be visible and creating a deadzone:

scroll_container.v_scroll.enabled = true
scroll_container.scroll_deadzone = 50

Adding Content to ScrollContainer

For the ScrollContainer to function, it must have a child node that acts as the scrollable content. This is typically a Control-derived node. Here’s how you might add a VBoxContainer with some buttons to the ScrollContainer:

var vbox =

for i in range(10):
    var button =
    button.text = "Button %d" % i

The ScrollContainer now contains a vbox with 10 buttons, which will activate the vertical scrollbar if they exceed the height we’ve previously set.

Setting up Scroll Snap and Scroll Following

In some cases, you might want the ScrollContainer to automatically adjust its view to focus on certain elements, such as automatically scrolling to the bottom in a chat application. Using the `ensure_control_visible` method, we can achieve this. Say we want to focus on the last button we just created:

scroll_container.ensure_control_visible(vbox.get_child(vbox.get_child_count() - 1))

Additionally, Godot 4 introduces more control over scrolling behavior. You can set properties to “snap” the scrolling to child controls or make scrolling smooth and gradual. These properties give you more control over the user’s scrolling experience.

Exploring these basic ScrollContainer functionalities gives you the foundation to include varying amounts of content within your UI without compromising on space or readability. In the next part of the tutorial, we’ll look into more advanced features and customization options for ScrollContainer to make your UI even more polished and user-friendly.Now that you’ve set up the ScrollContainer and added content to it, you might want to further customize and refine its behavior. We’ll explore several more advanced features that can provide a better experience for your users.

Customizing Scrollbar Appearance

To enhance your UI’s look, Godot allows you to customize the appearance of the scrollbars within the ScrollContainer. You can adjust the scrollbar’s theme and modify properties like its color, size, and even the grabber icon used.

Here is an example of how to change the scrollbar’s color and width:

# Assuming 'scrollbar_theme' is a predefined 'Theme' resource
scroll_container.scrollbar_theme = scrollbar_theme

# Customizing the vertical scrollbar's size and color in the theme
scroll_container.get_v_scrollbar().custom_step = 50
scroll_container.get_v_scrollbar().size_flags_horizontal = SIZE_EXPAND_FILL
scroll_container.get_v_scrollbar().theme.set_color("font_color", Color(0.5, 0.5, 0.5, 1))

Remember to bump up the deadzone size if you want the custom scrollbar to be more responsive to content size changes.

Programmatic Scrolling

Sometimes, you may need to scroll to a specific position within the ScrollContainer programmatically rather than relying on user input. Godot provides a straightforward way to achieve this.

Here is how to scroll the window to the top-left corner:

scroll_container.scroll_vertical = 0
scroll_container.scroll_horizontal = 0

And here’s an example that scrolls to the bottom-right corner:

scroll_container.scroll_vertical = scroll_container.get_v_scrollbar().max_value
scroll_container.scroll_horizontal = scroll_container.get_h_scrollbar().max_value

Responding to Scroll Events

You might want to react to the user’s scrolling in your code—for instance, to load more items in a lazy-loaded list or to create dynamic effects. Connect to the `scroll_ended` signal to trigger actions after the user stops scrolling.

Connecting a ScrollContainer signal in GDScript:

scroll_container.connect("scroll_ended", self, "_on_scroll_ended")

func _on_scroll_ended():
    print("Scrolling has stopped.")

Handling Overflow

Sometimes, you need more complex behavior when content overflows the size of the ScrollContainer. For example, you may want to hide or show certain UI elements based on whether the content is overflowing. You can check if scrollbars are active to make these decisions.

Here’s a snippet that checks whether the vertical scrollbar is active:

func _process(delta):
    if scroll_container.get_v_scrollbar().is_visible_in_tree():
        # Handle vertical overflow, such as by showing an arrow or indicator.
        # Handle when there is no overflow.

Integrating with the GUI Input System

Finally, you may want to allow users to interact with the ScrollContainer using the keyboard or gamepad. By default, ScrollContainer will not react to such inputs, but we can easily set it up.

Here’s a basic integration to allow scrolling with the arrow keys:

func _unhandled_input(event):
    if event is InputEventKey:
        if event.scancode == KEY_DOWN:
            scroll_container.scroll_vertical += 10
        elif event.scancode == KEY_UP:
            scroll_container.scroll_vertical -= 10

Through these advanced features and customization options, you can gain a solid understanding of how to use the ScrollContainer effectively in your projects. It’s not just about making content fit on the screen—it’s about creating a seamless and engaging experience for users to interact with your content. Godot’s ScrollContainer is a powerful tool for achieving just that, and we encourage you to experiment and see how it can enhance your own projects.Continuing with our deeper dive into the ScrollContainer, let’s explore more ways to leverage its capabilities to create robust and responsive UIs.

Scrolling with Touch and Drag

For platforms with touch support, you might want to allow users to drag the content within the ScrollContainer. Enabling touch or drag to scroll can provide a natural and intuitive experience, especially on mobile devices. Here’s how you can set that up:

func _ready():
    # Set touch scrollable to true for touch and drag functionality

Adding and Removing Content Dynamically

In a dynamic UI, content might be added or removed on the fly. Here’s how you might add an element dynamically to a VBoxContainer within the ScrollContainer:

func add_item(text):
    var item =
    item.text = text
    # Optionally scroll to the new item

# Usage
add_item("New Dynamic Item")

Similarly, to remove an item:

func remove_item(item: Control):

It’s possible that after adding or removing content, the ScrollContainer’s content size changes, yielding more or less need for scrolling. Following a dynamic change, you might have to update the scroll position or adjust related UI elements.

Listening for Scroll Changes

There might be scenarios where you want to perform specific actions when the ScrollContainer is scrolled – for instance, to update other elements of the UI or to load content as needed dynamically. We can achieve this by connecting to the `gui_input` signal and checking for scroll events.

scroll_container.connect("gui_input", self, "_on_ScrollContainer_gui_input")

func _on_ScrollContainer_gui_input(event):
    if event is InputEventPanGesture:
        # Apply the pan gesture's delta to the scroll values
        scroll_container.scroll_horizontal -= event.relative.x
        scroll_container.scroll_vertical -= event.relative.y

Animating Scroll Movements

For a smooth user experience, you may want to animate the scroll motion when jumping to different parts of the content. Here’s an example using ‘Tween’ to animate:

var tween =

func animate_scroll_to(pos):
    tween.interpolate_property(scroll_container, "scroll_vertical", scroll_container.scroll_vertical, pos, 1.0, Tween.TRANS_LINEAR, Tween.EASE_OUT)

# Call this function to animate scrolling to the 100-vertical position

By using tweens, we can avoid sharp jumps in the viewport, instead providing a pleasing, gradual transition as the content moves.

Adjusting Scroll Speed

Different users may have different preferences for how quickly content scrolls. You might offer a setting for scroll speed, or you might adjust it based on the type of content you’re displaying.

Here’s how you can adjust the scroll speed:

func _input(event):
    if event is InputEventMouseButton:
        if event.button_index == BUTTON_WHEEL_DOWN:
            scroll_container.scroll_vertical += 10 * event.factor
        elif event.button_index == BUTTON_WHEEL_UP:
            scroll_container.scroll_vertical -= 10 * event.factor

Note that in this example, `event.factor` can be thought of as a sensitivity or speed multiplier for the scroll wheel input.

Integrating ScrollContainer into your Godot projects requires understanding these advanced practices. Through dynamically updating content, responding to user interactions, and customizing scroll behaviors, you can build sophisticated and user-friendly UI systems. Implementing these code examples will enable you to tackle a variety of UI challenges with confidence and creative flexibility.

Continuing Your Godot Learning Journey

Now that you’ve gotten a taste of implementing ScrollContainers in Godot, it’s time to broaden your skills and tackle more exciting game development projects. Your journey into the world of game creation is just beginning, and there’s no better way to continue than with structured, project-based learning.

At Zenva, our Godot Game Development Mini-Degree is the perfect next step. It’s a comprehensive online course that covers a wide array of topics in Godot. Whether you’re looking to enhance your 2D platformers or dive into the realms of 3D, our curriculum is designed to provide you with real-world skills that you can apply straight away to your own projects.

For those who want to explore our full range of Godot tutorials, have a look at our Godot courses. With over 250 supported courses, Zenva offers content that will take you from the basics all the way to professional game development. Enhance your portfolio, learn at your own pace, and join us on a journey to mastering coding, game creation, and much more. Now is the time to take that next big leap and make your game development dreams a reality!


With the skills you’ve honed in this tutorial, you’re well on your way to creating interactive and content-rich UIs using Godot’s ScrollContainer. But don’t stop here; each game development journey is filled with continuous learning and exploration. Our Godot Game Development Mini-Degree is designed to further unlock your potential and guide you through the next stages of crafting captivating and polished games.

Join us at Zenva, and let’s turn your creative visions into reality, together. With Zenva, you’ll have access to the tools and knowledge needed to take on the gaming world by storm. So why wait? Dive deeper into Godot and beyond, and let your game development adventure soar to new heights!

Python Blog Image

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