LinkButton in Godot – Complete Guide

Welcome to this in-depth tutorial on the LinkButton class in Godot 4, where we’ll explore this handy UI node up close. LinkButtons are integral to creating intuitive and user-friendly interfaces in your games and applications. These special buttons behave like hyperlinks you might find on a web page and can be an elegant solution to navigating within your Godot project or even linking to external resources. If you’ve ever wanted to guide players to your website or open a document from your game, mastering LinkButton is your next step.

What is a LinkButton?

A LinkButton is a type of button within the Godot Engine that functions similarly to a hyperlink in a web browser. It inherits from BaseButton, which means it shares common properties and methods with other button types in Godot. The primary use of a LinkButton is to provide a UI element that, when clicked, can change the context in which the user is operating. This could include opening a web page, accessing a file in the file explorer, or even starting an email client.

What is it used for?

The primary use of a LinkButton is navigation. By setting the uri property, developers can direct users to a variety of destinations, both within the game environment and to external locations. LinkButton is perfect for directing players to your game’s website, linking to a help document, or any situation where you’d like to offer a direct line to additional resources without breaking immersion.

Why should I learn it?

Understanding how to implement and customize LinkButtons in Godot is an excellent skill that can greatly enhance the user experience of your project. Whether you are a beginner looking to add professional elements to your game or an experienced developer aiming for increased user engagement, learning to use the LinkButton will provide you with a simple yet powerful tool to improve navigation and interactivity. Plus, Godot’s ease of use makes working with UI elements like the LinkButton an accessible task for developers of all skill levels.

CTA Small Image

Basic Setup of a LinkButton in Godot

Let’s start by adding a LinkButton to a scene in Godot. Here’s how you can create a basic LinkButton and configure it to point to an external URL.

var link_button =
link_button.text = "Visit Zenva Academy"
link_button.underline_mode = LinkButton.UNDERLINE_MODE_ALWAYS
link_button.uri = ""

# Add the LinkButton to the scene

This code creates a new LinkButton, sets the display text, ensures the underline is always visible, and defines the destination URL that will be opened in the web browser when the button is clicked. The last step adds the LinkButton as a child to the current node.

Connecting a LinkButton to a Signal

Godot’s signal system allows us to control what happens when a LinkButton is pressed. Here we connect the ‘pressed’ signal to a custom function:

link_button.connect("pressed", self, "_on_LinkButton_pressed")

func _on_LinkButton_pressed():

Every time the LinkButton is pressed, the ‘_on_LinkButton_pressed()’ function will be called, triggering the OS’s shell to open the defined URI.

Styling a LinkButton

To differentiate your LinkButton from standard buttons, styling is key. You can set a custom font and color:

var font =
font.font_data = load("res://path/to/your/font.ttf")
font.size = 18

link_button.add_font_override("font", font)
link_button.add_color_override("font_color", Color(0.1, 0.6, 0.9))

# Optionally, change the mouse over color
link_button.add_color_override("font_color_hover", Color(0.2, 0.8, 1.0))

The code above sets a custom font, a base color for the text, and an optional hover color that will be used when the mouse is over the button.

Embedding a LinkButton in an In-Game UI

LinkButtons are often used within an in-game UI layout. Here’s an example of embedding a LinkButton in a VBoxContainer:

var vbox =

var link_button =
link_button.text = "Check for Updates"
link_button.underline_mode = LinkButton.UNDERLINE_MODE_ALWAYS
link_button.uri = ""


After creating the VBoxContainer and adding it to the scene, the LinkButton is created and configured with its text, underline, and URI. It is then added as a child to the VBoxContainer, which will automatically manage the layout.

This concludes the second part of our tutorial. You have learned how to create and configure LinkButtons in Godot, connect them to signals for interaction, apply custom styling, and embed them in a UI layout. In the next part, we will continue with more advanced configurations and uses of LinkButtons.

Increasing the functionality and improving the user experience with LinkButtons continues as we delve into more advanced topics. Let’s enhance the dynamic behavior of LinkButtons and consider practical examples of use in a game or application.

When setting up a LinkButton, you might want to add logic that determines its behavior based on the user’s actions or changes in the game’s state:

func update_link_button_state():
    if player.has_item("map"):
        link_button.text = "View the Map"
        link_button.uri = "res://map.png"
        link_button.text = "Purchase Map"
        link_button.uri = ""

Here, the LinkButton provides a direct interface with the game’s logic by offering different actions based on the player’s inventory. It could open an in-game resource, like a map, or take the player to an external website to purchase it.

For games that might release updates or patches, providing real-time information to players is essential. Here’s how you can use a LinkButton to check for updates:

link_button.connect("pressed", self, "_on_LinkButton_pressed")

func _on_LinkButton_pressed():
    if is_update_available():
        link_button.text = "Download Update"
        link_button.uri = ""
        link_button.text = "You have the latest version"
func is_update_available():
    # Logic to check for updates
    return true # or false, based on the update check

This example shows the LinkButton altering its text and associated URI if an update is available, guiding the player towards the download.

Let’s also look at how to ensure the LinkButton’s visibility and accessibility by optionally adding a tooltip that gives more information:

link_button.hint_tooltip = "Click to visit Zenva Academy"

Tooltips can be particularly helpful for new players or when the function of the LinkButton may not be immediately apparent.

For educational games or applications, you may want to direct users to a glossary or tutorial. Here’s a scalable way to create a series of LinkButtons for a list of resources:

var resources = [
    {"text": "Glossary", "uri": "res://glossary.pdf"},
    {"text": "Tutorial", "uri": "res://tutorial.pdf"},
    # Add more resources as needed

for resource in resources:
    var new_link_button =
    new_link_button.text = resource["text"]
    new_link_button.uri = resource["uri"]

This efficient approach uses a loop to populate a VBoxContainer with multiple LinkButtons, each pointing to a different resource defined in a dictionary.

Accessibility can be improved even further by enabling keyboard navigation through your LinkButtons. You can manually define the focus order to ensure a logical navigation flow:

link_button1.focus_mode = Control.FOCUS_ALL
link_button1.focus_neighbour_bottom = link_button2.get_path()

link_button2.focus_mode = Control.FOCUS_ALL
link_button2.focus_neighbour_top = link_button1.get_path()

You have the ‘focus_neighbour_bottom’ and ‘focus_neighbour_top’ properties assigned for two LinkButtons, creating a navigable loop for users who prefer or require keyboard controls.

Lastly, you may want to signal to the user that the LinkButton will open their web browser. This can enrich the UX by aligning their expectations with the button’s functionality:

link_button.mouse_entered.connect(self, "_on_LinkButton_mouse_entered")
link_button.mouse_exited.connect(self, "_on_LinkButton_mouse_exited")

func _on_LinkButton_mouse_entered():

func _on_LinkButton_mouse_exited():

These connection methods change the scene to display a notification when the mouse hovers over the LinkButton, and revert back when it’s no longer hovered. This notification could remind users they are leaving the game environment.

Through these examples, you’ve learned how to leverage the properties and signals of LinkButtons to improve in-game navigation, keep players informed, and enhance the overall user experience. Integrating these practices into your Godot projects will create polished interfaces that are both functional and user-friendly.

Moving on to more nuanced features of the LinkButton, we’ll explore conditional formatting, integrating with themes, and adding custom scripts to manage complex behaviors.

Conditional formatting can be useful when you want LinkButtons to reflect different states. For instance, you can deactivate the LinkButton if a condition is not met and change its appearance to indicate its inactive state:

func update_link_button_availability():
    if has_required_item():
        link_button.disabled = false
        link_button.modulate = Color(1, 1, 1) # normal color
        link_button.disabled = true
        link_button.modulate = Color(0.5, 0.5, 0.5) # grayed out

func has_required_item():
    # Checks for an item's presence in the player's inventory
    return true # or false

Using this setup, a LinkButton will appear normal and be interactive only when the player meets certain conditions, like possessing a required item.

LinkButtons, like all control nodes in Godot, can be styled with Themes. Here is how you might customize your LinkButton using a Theme resource:

var theme =

var custom_font =
custom_font.font_data = load("res://fonts/YourFont.ttf")
custom_font.size = 14

theme.set_font("font", "LinkButton", custom_font)

link_button.theme = theme

With these lines, we’ve created a DynamicFont instance, set this font to our theme specifically for LinkButton nodes, and applied the new theme to our LinkButton.

In some situations, you may want LinkButtons to execute more complex logic than simply opening a URI. For these purposes, you can attach a script to a LinkButton and write custom functions:

link_button.connect("pressed", self, "_on_custom_link_button_pressed")

func _on_custom_link_button_pressed():
    # Implementing advanced logic here
    if user.is_authenticated():

Here, we’ve connected the ‘pressed’ signal to a custom function that checks for user authentication and performs actions accordingly.

It’s also possible to dynamically update the text and link of a LinkButton based on external data, such as from an API or a database:

func update_news_link_button():
    var latest_news = get_latest_news() # Assume this function retrieves the latest news title and URL
    link_button.text = latest_news.title
    link_button.uri = latest_news.url

func get_latest_news():
    # Placeholder function for fetching latest news
    return {"title": "New DLC Released!", "url": ""}

This function pair illustrates how you could set a LinkButton to display the latest news title and link to the full article with data fetched dynamically.

Creating a navigation bar with LinkButtons can be an elegant way to manage scene transitions. Here’s a framework for a horizontal menu bar using an HBoxContainer:

var hbox =

# Create and configure LinkButtons
var home_button = create_link_button("Home", "res://scenes/Home.tscn")
var settings_button = create_link_button("Settings", "res://scenes/Settings.tscn")
var about_button = create_link_button("About", "res://scenes/About.tscn")

# Add them to the HBoxContainer

func create_link_button(text, scene_path):
    var button =
    button.text = text
    button.connect("pressed", self, "_on_LinkButton_scene_change", [scene_path])
    return button

func _on_LinkButton_scene_change(scene_path):

This example demonstrates a horizontal menu bar where each LinkButton is responsible for changing the current scene.

Combining these techniques provides robust mechanisms for engaging users with your interface. You’re now equipped to take full advantage of the LinkButton control in Godot, customizing its behavior to suit diverse requirements and creating a more polished and user-centric gaming experience.

Continue Your Game Development Journey

Your exploration into the Godot Engine and the versatility of LinkButton doesn’t have to end here. If you’ve found a passion for creating immersive and interactive UIs, we encourage you to keep building on your knowledge.

Delve deeper into game creation with our comprehensive Godot Game Development Mini-Degree. This selection of courses is designed to expand your understanding of game development, guiding you through various aspects of using Godot 4. You’ll gain hands-on experience by working through projects step-by-step, enhancing your skills in both 2D and 3D game design, and learning how to implement advanced gameplay mechanics.

Whether you’re a beginner eager to get started or an experienced developer looking to specialize, the Mini-Degree is an invaluable resource that will help you progress. And for those looking to explore even further, our broad collection of Godot courses awaits, ready to help you become a confident and capable game developer. With Zenva, you’re on the path from beginner to professional.


As we wrap up our exploration of Godot’s LinkButton, it’s clear that mastering UI elements is key to crafting enjoyable and intuitive game experiences. The knowledge you’ve gained serves as a foundation from which to launch countless creative projects, each with the potential to captivate and engage players in unique ways. Remember, the journey through game development is continuous, and there’s always more to learn and create.

Looking to take your skills to the next level? Continue your educational adventure with us at Zenva Academy, where our Godot Game Development Mini-Degree awaits. Join a community of budding developers and industry veterans, all striving towards the common goal of bringing incredible games to life. Your dream game is within reach—let’s build it together with Godot and Zenva!

Python Blog Image

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