Up to date

This page is up to date for Godot 4.0. If you still find outdated information, please open an issue.

GDScript reference

GDScript is a high-level, object-oriented, imperative, and gradually typed programming language built for Godot. It uses an indentation-based syntax similar to languages like Python. Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration.

GDScript is entirely independent from Python and is not based on it.

History

Note

Documentation about GDScript's history has been moved to the Frequently Asked Questions.

Example of GDScript

Some people can learn better by taking a look at the syntax, so here's an example of how GDScript looks.

# Everything after "#" is a comment.
# A file is a class!

# (optional) icon to show in the editor dialogs:
@icon("res://path/to/optional/icon.svg")

# (optional) class definition:
class_name MyClass

# Inheritance:
extends BaseClass


# Member variables.
var a = 5
var s = "Hello"
var arr = [1, 2, 3]
var dict = {"key": "value", 2: 3}
var other_dict = {key = "value", other_key = 2}
var typed_var: int
var inferred_type := "String"

# Constants.
const ANSWER = 42
const THE_NAME = "Charly"

# Enums.
enum {UNIT_NEUTRAL, UNIT_ENEMY, UNIT_ALLY}
enum Named {THING_1, THING_2, ANOTHER_THING = -1}

# Built-in vector types.
var v2 = Vector2(1, 2)
var v3 = Vector3(1, 2, 3)


# Functions.
func some_function(param1, param2, param3):
    const local_const = 5

    if param1 < local_const:
        print(param1)
    elif param2 > 5:
        print(param2)
    else:
        print("Fail!")

    for i in range(20):
        print(i)

    while param2 != 0:
        param2 -= 1

    match param3:
        3:
            print("param3 is 3!")
        _:
            print("param3 is not 3!")

    var local_var = param1 + 3
    return local_var


# Functions override functions with the same name on the base/super class.
# If you still want to call them, use "super":
func something(p1, p2):
    super(p1, p2)


# It's also possible to call another function in the super class:
func other_something(p1, p2):
    super.something(p1, p2)


# Inner class
class Something:
    var a = 10


# Constructor
func _init():
    print("Constructed!")
    var lv = Something.new()
    print(lv.a)

If you have previous experience with statically typed languages such as C, C++, or C# but never used a dynamically typed one before, it is advised you read this tutorial: GDScript: An introduction to dynamic languages.

Language

In the following, an overview is given to GDScript. Details, such as which methods are available to arrays or other objects, should be looked up in the linked class descriptions.

Identifiers

Any string that restricts itself to alphabetic characters (a to z and A to Z), digits (0 to 9) and _ qualifies as an identifier. Additionally, identifiers must not begin with a digit. Identifiers are case-sensitive (foo is different from FOO).

Identifiers may also contain most Unicode characters part of UAX#31. This allows you to use identifier names written in languages other than English. Unicode characters that are considered "confusable" for ASCII characters and emoji are not allowed in identifiers.

Keywords

The following is the list of keywords supported by the language. Since keywords are reserved words (tokens), they can't be used as identifiers. Operators (like in, not, and or or) and names of built-in types as listed in the following sections are also reserved.

Keywords are defined in the GDScript tokenizer in case you want to take a look under the hood.

Keyword

Description

if

See if/else/elif.

elif

See if/else/elif.

else

See if/else/elif.

for

See for.

while

See while.

match

See match.

break

Exits the execution of the current for or while loop.

continue

Immediately skips to the next iteration of the for or while loop.

pass

Used where a statement is required syntactically but execution of code is undesired, e.g. in empty functions.

return

Returns a value from a function.

class

Defines a class.

class_name

Defines the script as a globally accessible class with the specified name.

extends

Defines what class to extend with the current class.

is

Tests whether a variable extends a given class, or is of a given built-in type.

in

Tests whether a value is within a string, list, range, dictionary, or node. When used with for, it iterates through them instead of testing.

as

Cast the value to a given type if possible.

self

Refers to current class instance.

signal

Defines a signal.

func

Defines a function.

static

Defines a static function. Static member variables are not allowed.

const

Defines a constant.

enum

Defines an enum.

var

Defines a variable.

breakpoint

Editor helper for debugger breakpoints. Unlike breakpoints created by clicking in the gutter, breakpoint is stored in the script itself. This makes it persistent across different machines when using version control.

preload

Preloads a class or variable. See Classes as resources.

await

Waits for a signal or a coroutine to finish. See Awaiting for signals or coroutines.

yield

Previously used for coroutines. Kept as keyword for transition.

assert

Asserts a condition, logs error on failure. Ignored in non-debug builds. See Assert keyword.

void

Used to represent that a function does not return any value.

PI

PI constant.

TAU

TAU constant.

INF

Infinity constant. Used for comparisons and as result of calculations.

NAN

NAN (not a number) constant. Used as impossible result from calculations.

Operators

The following is the list of supported operators and their precedence.

Operator

Description<