Skip to main content
Back to path

Welcome to a Grasp lesson

Create a free account to keep studying and create your own study path.

Lesson 2

Navigating Godot Documentation and Help

Recommended resources

Hello! Welcome back to your course on mastering Godot.

In our last lesson, we took a tour of the Godot editor, familiarizing ourselves with the workspaces, docks, and viewport. You now have a mental map of your primary tool. Today, we build on that by learning how to use the most powerful feature of that tool: its integrated help system and documentation.

The learning outcome for this lesson is to use the Godot documentation and built-in help effectively. For a developer, especially one who prefers a "theory-first" approach like you, learning to be self-sufficient in finding information is the single most important skill. It transforms you from someone who follows tutorials into someone who creates solutions. We will explore the structure of Godot's documentation, how to navigate it efficiently, and how to apply it to solve real development problems.

1. What is an API? The Two Pillars of Godot Docs

Before diving into Godot's specifics, it's helpful to understand the concept of an API (Application Programming Interface). An API is essentially a list of all the building blocks and tools a software system (like a game engine) provides for you to use.

A great way to think about this is like a menu at a restaurant. The menu tells you what the kitchen can make, what ingredients are in each dish, and how to order it.

Godot API Basics | Godot Basics Tutorial | Ep 04

To start, watch this short clip from the Godot Tutorials channel. It uses the restaurant menu analogy to explain what an API is in the context of a game engine.

Watch from the beginning until 02:21. Focus on the analogy and the general idea of what an API provides.

Godot's documentation is divided into two main parts: the Manual and the Class Reference (the API).

  • The Manual: This is like a cookbook. It contains tutorials, guides on high-level concepts (like networking or physics), and best-practice explanations. You consult the Manual when you ask, "How do I approach a feature like a health bar?" or "What are the principles of 2D lighting?"
  • The Class Reference: This is the API, the dictionary of all of Godot's building blocks (classes). You consult the Class Reference when you ask, "What specific properties does a Sprite2D node have?" or "What function do I call to make a sound play?"

The next video gives an excellent overview of this distinction and why embracing the documentation is so critical.

Why the godot documentation is your best friend (And how to use it)

This video from Karto, titled 'Why the godot documentation is your best friend', provides a fantastic practical introduction to both parts of the docs.

Watch from the beginning until 02:05. This segment will introduce you to the Manual and the Class Reference and explain their different purposes.

2. How to Read the Class Reference

Since you have a programming background, you'll find the Class Reference to be your most-used resource. Every node, resource, and object in Godot has a dedicated page in the Class Reference. Understanding how to read these pages is key.

A class page is typically broken down into these key sections:

  • Inheritance Chain
  • Description
  • Properties
  • Methods
  • Signals
  • Constants & Enums

Inheritance: The Family Tree

One of the most important concepts in Godot is inheritance. Every node type inherits functionality from its "parent" class. For example, a CharacterBody2D (a node for player characters) is also a PhysicsBody2D, which is also a CollisionObject2D, which is also a CanvasItem, which is also a Node.

This means a CharacterBody2D has access to all the properties and methods of its parents and grandparents, all the way up to the base Node class. This is why you can call get_node() on any node in your scene. That function belongs to the Node class, and all other nodes inherit from it.

When you can't find a function you're looking for on a specific node's documentation page, the next step is always to check its parent's page.

Why the godot documentation is your best friend (And how to use it)

The Karto video has an excellent segment explaining inheritance with a practical example.

Watch from 08:42 to 10:51. Pay close attention to the example of looking for the 'pressed' signal on a Button node and finding it on its parent, BaseButton.

Properties, Methods, and Signals

These are the core components of any class:

  • Properties are the variables or data associated with the class (e.g., position, rotation, texture). They define the node's state.
  • Methods are the functions you can call on the class to make it do something (e.g., move_and_slide(), play(), queue_free()).
  • Signals are events that the class can emit to notify other parts of your game that something happened (e.g., body_entered, timeout, pressed).

Why the godot documentation is your best friend (And how to use it)

Let's return to the Karto video to see a detailed breakdown of how to read the Properties and Methods sections.

Watch from 03:57 to 08:42. This is a dense but very important section. Focus on these key points: How property names in code (snake_case) can differ from the Inspector. How to find a property's true name by hovering in the Inspector. Understanding a method's signature: its return type, name, and parameters (including optional ones).

To solidify this, you can use the official documentation page as a reference. It provides a static, text-based breakdown of a class API page.

How to read the Godot API

Skim through this official documentation page, 'How to read the Godot API'. You don't need to memorize it, but see how it formally lays out the sections we've just discussed in the video.

Quickly scroll through this entire page. Notice the headings for Inheritance, Properties, Methods, Signals, etc. This reinforces the structure of the documentation you'll be using constantly.

3. Accessing and Using the Docs in the Editor

Now that you know what to look for, let's cover how to access this information quickly from within the Godot editor.

The primary ways to get help are:

  1. Pressing F1: With the text editor open, this opens the "Search Help" dialog, where you can search for any class, method, property, or constant.
  2. Ctrl + Left Click: While in the script editor, holding Ctrl and clicking on any class name, function, or built-in variable will jump directly to its documentation page.
  3. Right-Click in the Inspector: You can right-click any property in the Inspector and select "Open Documentation".
  4. The "Search Help" Button: In the top-right of the Script workspace, there is a magnifying glass icon to open the search dialog.
Godot Editor Built-in Help Search for 'clipboard'
This is the powerful 'Search Help' window you can access with F1. It allows you to quickly find any class, method, constant, or theme property in the engine's API.

The following video clip demonstrates all of these methods in action.

Why the godot documentation is your best friend (And how to use it)

This clip from the Karto video is a perfect summary of the different ways to access the documentation efficiently.

Watch from 14:33 to 15:51. Try to memorize the key shortcuts: F1 and Ctrl+Click.

Godot Script Editor Shortcuts
This image lists several useful keyboard shortcuts, including those for accessing documentation (`F1`, `Ctrl+Click`). Keeping these in mind will drastically speed up your workflow.
Test your understanding!

Let's do a practical exercise. Imagine you're making your Metroidvania and you need the player's health to be a whole number (an integer), but you want to display it on a progress bar that requires a floating-point value (a number with decimals).

You have an integer variable, and you need to convert it to a float. How would you find out how to do this using the built-in help?

Your task:

  1. Open Godot and create a new script (it doesn't need to be attached to anything).
  2. Use the help features to figure out how to convert an integer to a float.
Show answer

There are a few ways you could have solved this:

  1. F1 Search: Press F1 and search for "int" or "convert to float". This would lead you to the @GDScript page or the int built-in type page. There, you might find information about casting or the float() constructor.
  2. Look up int: In your script, type the word int. Now, hold Ctrl and click on it. This takes you directly to the documentation for the int built-in type. You'd see it has no special conversion methods.
  3. Look up float: In your script, type float. Ctrl+Click on that. This takes you to the float documentation. In the description, you will find it can be constructed from an integer, like so: var my_float = float(10).

The most direct solution is simply float(your_integer_variable). The goal of the exercise was to practice the process of finding that answer yourself.

A Word of Caution: The Docs Are Not Perfect

While the Godot documentation is excellent, it is a community-driven effort and sometimes has gaps. Certain assumptions are sometimes made that can confuse newcomers. For example, the documentation for a class might not explicitly state that it's a Singleton (a globally accessible object) or that it must be in the Scene Tree to function correctly (e.g., for signals to work).

Godot API Basics | Godot Basics Tutorial | Ep 04

The Godot Tutorials video you saw earlier has a great segment on this topic. It highlights some common pitfalls you might encounter when reading the docs.

Watch from 13:32 to 17:20. This will show you examples using the Timer and OS classes, where the documentation alone might not give you the full picture without a little extra context or experimentation.

The key takeaway is to be a detective. If something doesn't work as you expect after reading the docs, consider the context: Does this node need to be in the scene? Is this class perhaps a global singleton? This critical thinking, combined with documentation, is what builds expertise.

Conclusion

In this lesson, you've gained the essential skill of navigating and utilizing Godot's documentation. This is your key to unlocking the full power of the engine and becoming a self-sufficient developer.

Here are the main takeaways:

  • The Manual is for high-level concepts; the Class Reference (API) is for the specifics of every building block.
  • Inheritance is crucial; functionality often lives in a parent class.
  • A class page details its Properties (data), Methods (actions), and Signals (events).
  • Your most important shortcuts are F1 (Search Help) and Ctrl+Click (Go to Definition).
  • Always be prepared to think critically, as the docs sometimes assume context.

You are now equipped to explore Godot's vast feature set on your own.

In our next lesson, we will put this new skill to immediate use as we explore the most fundamental concept in Godot: the node and scene architecture. You'll learn how these two concepts are used to structure everything in your game, from the player character to the UI to the entire game world.