MenuButton in Godot – Complete Guide

Welcome to our tutorial on the MenuButton class in the Godot 4 game engine! If you’ve been curious about enhancing the user interface of your game or application, this tutorial will guide you through the fundamentals of implementing and customizing menu buttons. The MenuButton is a versatile node that brings interactivity and functionality to your project, enabling users to trigger actions and navigate your game’s menus with ease. Whether you’re a beginner taking your first steps in Godot or an experienced developer looking to refine your UI design, mastering the MenuButton node is a valuable skill to add to your toolkit. Ready to get started? Let’s dive into the world of Godot’s UI elements together and uncover what makes the MenuButton an indispensable component in your development journey.

What is MenuButton?

// A simple example of MenuButton usage in GDScript
var menu_button =

func _ready():
    var popup = menu_button.get_popup()
    popup.add_item("Start Game")

The MenuButton class is a UI element that inherits from the Button class, which in turn inherits from the base Control classes within Godot. In essence, MenuButton is a specialized button that, when clicked, displays a PopupMenu for more options. This functionality is useful for creating drop-down menus that maintain a clean aesthetic while offering users extra choices without cluttering the interface.

What is it Used For?

MenuButtons are often a core component of user interfaces within games and applications. They can be used for various purposes:

  • Navigation menus in-game, where players can start, load, or save a game
  • Options or settings menus to adjust game controls, audio levels, or graphical settings
  • Contextual menus that appear in editors or tools when right-clicking on an object

Why Should I Learn It?

Understanding how to implement and use MenuButtons can significantly impact the usability of your game or application. Here are some reasons why learning MenuButton is beneficial:

– **User Experience**: Elevate the player’s experience with intuitive and accessible menus.
– **Clean UI Design**: Keep the interface uncluttered by consolidating options into pop-up menus.
– **Versatility**: Use MenuButtons in a variety of contexts, from main game menus to in-game interactive elements.
– **Customization**: Style and modify pop-up menus to match the aesthetic and feel of your game.

By learning to incorporate MenuButtons, you’re enhancing not just the visual aspect of your interface, but also making your game more engaging and user-friendly. Join us as we explore this class through practical examples, and start building a more polished and interactive UI for your project today!

CTA Small Image

Creating a Basic MenuButton

To start using the MenuButton in your Godot project, you need to first create it and add it to your scene. The following example showcases how to create a MenuButton and add it to the scene using GDScript:

var menu_button =

func _ready():
    menu_button.text = "Options"

Once you have your MenuButton added to the scene, the next step is to configure the popup menu and add items to it:

func _ready():
    menu_button.text = "Options"
    var popup = menu_button.get_popup()
    popup.add_item("Start Game")

Connecting Menu Items to Functions

To make your menu items functional, you’ll want to connect them to specific callback functions. This following example will show you how to do this using the ‘id_pressed’ signal:

func _ready():
    var popup = menu_button.get_popup()
    popup.add_item("Start Game", 0)
    popup.add_item("Settings", 1)
    popup.add_item("Quit", 2)
    popup.connect("id_pressed", self, "_on_MenuButton_item_selected")

func _on_MenuButton_item_selected(id):
    match id:
            print("Start Game Selected")
            print("Settings Selected")

Customizing the Popup Appearance

Customization is key to ensuring that your MenuButton fits the style of your game. Here’s how you can customize the appearance of the popup menu:

// Assume 'menu_button' is already added as a child
var popup = menu_button.get_popup()
popup.add_item("Start Game")
popup.get_item(0).set_custom_color(FontColor, Color(1,0,0)) // Red Color for 'Start Game'

You can also customize the popup by modifying its themes and styles. Here’s an example of how to set a custom style for the popup menu:

// Create a StyleBoxFlat for customization
var style =
style.set_bg_color(Color(0.1, 0.1, 0.1)) // Dark gray background
style.set_border_color(Color(0.8, 0.8, 0.8)) // Light gray border
style.set_border_width_all(2) // Border width of 2 pixels

// Apply the style to the popup
var popup = menu_button.get_popup()
popup.add_style_override("panel", style)

Adding Icons and Shortcuts to Menu Items

Enhancing the visual appeal and utility of your MenuButton popup can be achieved by adding icons and keyboard shortcuts to the menu items:

var popup = menu_button.get_popup()

// Assume 'icon_texture' is a loaded texture for the icon
var icon_texture = preload("res://icon.png")

// Assume 'shortcut' is a ShortCut resource for CTRL+Q
var shortcut =

// Add item with an icon and a shortcut
popup.add_item("Quit", 0, icon_texture)
popup.set_item_shortcut(0, shortcut)

Remember to load actual textures and create real ShortCut resources for the icons and keyboard shortcuts to work in your actual project. This example is to demonstrate the syntax and methods required to add these enhancements to a MenuButton.

Utilizing these basics, you can create a highly functional and appealing MenuButton for your Godot projects. In the next part, we will explore more advanced features and capabilities of MenuButtons, such as handling multiple sub-menus and tweaking the behavior of the popup menu.In more advanced scenarios, you might want to create sub-menus within your MenuButton’s popup. This can add another layer of organization and accessibility to your UI. Here’s how you can implement a sub-menu within your MenuButton popup:

// Assume 'menu_button' is already added as a child
var popup = menu_button.get_popup()
popup.add_submenu_item("More Options", "options_submenu")
var submenu = popup.get_node("options_submenu")
submenu.add_item("Submenu Item 1")
submenu.add_item("Submenu Item 2")

Handling multiple sub-menus can be just as straightforward. You can create and configure them as shown in the example below:

// Adding a second sub-menu to the MenuButton's popup
popup.add_submenu_item("Advanced", "advanced_submenu")
var advanced_submenu = popup.get_node("advanced_submenu")
advanced_submenu.add_item("Advanced Option 1")
advanced_submenu.add_item("Advanced Option 2")

To customize the appearance of sub-menus, you could apply a different theme or set individual styles as needed. For example, setting a custom color for the sub-menu items:

// Set custom color for items in submenu
submenu.get_item(0).set_custom_color(FontColor, Color(0,1,0)) // Green Color for 'Submenu Item 1'
submenu.get_item(1).set_custom_color(FontColor, Color(0,0,1)) // Blue Color for 'Submenu Item 2'

You may want to manipulate the state of items within your MenuButton popup programmatically, such as disabling an option or hiding it. Here’s how you can enable or disable a specific item:

// Disabling the 'Quit' menu item
var quit_item_idx = popup.get_item_index(2) // Assuming 'Quit' has an index of 2
popup.set_item_disabled(quit_item_idx, true)

In some cases, you’ll want to respond to user actions within your UI by updating the state of your MenuButton interactively:

// Toggling the 'Settings' menu item based on user preferences
func toggle_settings_item(enabled):
    var settings_item_idx = popup.get_item_index(1) // Assuming 'Settings' has an index of 1
    popup.set_item_disabled(settings_item_idx, !enabled)

Menu items can also be hidden or made visible depending on the context of your application:

// Hide the 'Settings' menu item
popup.set_item_visible(settings_item_idx, false)

Lastly, it’s useful to dynamically build menus in response to in-game events. For example, a context menu that changes depending on which in-game object the player has selected. Here’s how to clear the old menu and add new items dynamically:

// Use this function to update the context menu
func update_context_menu_with_item(selected_item):
    popup.clear() // Remove all existing items
    popup.add_item("Action for " + selected_item)
    popup.add_item("Another action")
    // ... Add more actions relevant to the 'selected_item'

By learning how to manipulate the MenuButton in Godot, you can create dynamic and responsive user interfaces that adjust based on the player’s actions and the state of the game. This allows you to create a professional and polished experience that will resonate with players. With practice, you’ll be able to take full advantage of this powerful UI node and build complex menu systems tailored to your project’s needs.Managing the appearance and behavior of your MenuButton and its popup menu is essential for integrating it seamlessly within your game. Here’s how to change the popup’s direction, in case the default bottom opening direction doesn’t fit your UI design:

// Setting the popup direction to open upwards

If you want to connect MenuButton signals to functions dynamically, which is especially useful when your menu is being built at runtime, you may write:

// Connect the 'id_pressed' signal dynamically to a function
menu_button.get_popup().connect("id_pressed", self, "on_menu_item_selected")

func on_menu_item_selected(id):
    print("Selected item ID: ", id)

You can further control the MenuButton’s popup menu by setting a minimum size, ensuring that the menu is neither too small nor disproportionately large relative to the UI design:

// Setting a minimum size for the popup menu
menu_button.get_popup().rect_min_size = Vector2(200, 100)

For high visual standards, developers may want to differentiate the popup by using custom fonts. Here’s how you set a custom font for your MenuButton’s popup:

// Assume 'custom_font' is a loaded DynamicFont resource
var custom_font = preload("res://path/to/your/font.tres")

// Set the custom font for the popup menu items
menu_button.get_popup().add_font_override("font", custom_font)

Tooltips can be an excellent way to inform your users about the functionality of each menu item without cluttering the UI:

// Adding tooltips to popup menu items
menu_button.get_popup().set_item_tooltip(0, "Start a new game.")
menu_button.get_popup().set_item_tooltip(1, "Open settings menu.")
menu_button.get_popup().set_item_tooltip(2, "Exit the game.")

Sometimes, you may need to add a checkbox or a radio button to a menu item, especially useful for toggling settings:

// Adding a checkbox to a popup menu item
menu_button.get_popup().add_check_item("Enable Sound", 3)
menu_button.get_popup().set_item_checked(3, true)  // Default to checked

// Responding to the checkbox toggle
menu_button.get_popup().connect("id_pressed", self, "_on_toggle_sound")

func _on_toggle_sound(id):
    if id == 3:
        var sound_enabled = menu_button.get_popup().is_item_checked(id)
        print("Sound enabled: ", sound_enabled)

Finally, it is often necessary to update the MenuButton to reflect changes in the game state or player progress. Here is how you could dynamically update the text of menu items:

// Updating the text of a menu item
func update_menu_option_text(old_text, new_text):
    var item_idx = menu_button.get_popup().get_item_index_by_text(old_text)
    if item_idx != -1:
        menu_button.get_popup().set_item_text(item_idx, new_text)

Now you are equipped with a deeper understanding of the customizations and dynamic functionalities that you can implement with the MenuButton in Godot. Each of these code snippets can be used to refine the user interface of your Godot project, making it not only more interactive and user-friendly but also adaptable to varying requirements and design preferences. Keep experimenting with these elements, and you’ll find your MenuButtons becoming an integral part of your game’s navigation and settings experience.

Where to Go Next in Your Godot Journey

You’ve taken some important first steps in mastering UI elements with the MenuButton in Godot, and we at Zenva applaud your progress! But don’t let your learning journey end here. To dive deeper and expand your game development skills, we invite you to check out our comprehensive Godot Game Development Mini-Degree. This collection of courses will guide you through the creation of your own games, covering topics such as 2D and 3D game development, GDScript, and much more, in the Godot 4 engine.

Our Mini-Degree is designed for learners of all levels, perfect for those just starting out or for seasoned developers looking to refine their skills. With flexible learning options and project-based courses, you’ll have the chance to build a portfolio of games in different genres and gain valuable experience in the process. And upon completion, you’ll earn certificates to validate your accomplishments.

For an even broader collection of resources, explore our full set of Godot courses, spanning everything from beginner to advanced techniques. Continue your learning journey with us, and take your Godot skills from beginner to professional. Happy coding!


Embarking on your development journey with Godot’s UI tools such as MenuButton can transform your game design into an immersive and professional experience. We hope this tutorial has inspired you and shown you the flexibility and depth that Godot offers. Remember, a responsive and visually appealing UI not only delights your users but can also be a defining feature of your game. So, take these lessons, apply them, and watch as your players enjoy a smoother and more intuitive interface.

Continue crafting amazing games and enhancing your skill set with Zenva’s Godot Game Development Mini-Degree. Whether you’re refining your UI design or branching out into new gaming territories, we’re here with you every step of the way to guide, educate, and motivate. Let’s keep the creative coding flowing, and let the power of Godot unleash your game development potential!

Python Blog Image

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