Singleton Pattern

The Singleton pattern makes sure a class has exactly one object and gives every script one way to reach it. Use it for things a game has only one of: the settings, the save system, the score keeper.

In GDScript, a static var holds the single object, and a static func creates it the first time someone asks for it:

# game_settings.gd
class_name GameSettings
extends RefCounted

static var _instance: GameSettings = null

var volume := 50

static func get_instance() -> GameSettings:
	if _instance == null:
		_instance = GameSettings.new()
		print("Creating settings")
	return _instance

_instance belongs to the class, not to an object, so every script sees the same variable. The first call finds it empty and creates the object; every later call returns that same object.

# main.gd
var a := GameSettings.get_instance()
var b := GameSettings.get_instance()
a.volume = 80
print(b.volume)
print(a == b)

Creating settings
80
true

a and b are two variables holding one object, so the change made through a shows through b. For objects, == is true only when both sides are the same object.

GDScript cannot make _init() private, so nothing stops a script from calling GameSettings.new() and getting a second object. The underscore in _instance and the get_instance() method are the agreement: scripts ask for the object, they never create it.

In a Godot project, the usual way to get one shared object is an autoload: a script you register in Project Settings, which Godot creates once when the game starts and makes available by name in every script. It is a Singleton that Godot manages for you. Autoloads are set up in the editor, so the challenges here build the pattern in code with static var.