Fix: Godot Autoload/Singleton Not Accessible from Other Scripts

Here is how to fix Godot autoload singleton not accessible. You set up an autoload in Godot 4 to manage global game state—a score tracker, an audio manager, a save system. You try to access it from another script and get Identifier not found: GameManager. The autoload is registered, the script runs on its own, but nothing else in your project can see it.

The Symptom

You have a script registered as an autoload in Project → Project Settings → Autoload. When you try to reference it by name from another script, Godot throws an error:

# player.gd
func collect_coin():
    GameManager.score += 1  # Error: Identifier "GameManager" not found

Or you see the autoload node in the running scene tree under the Remote tab, but its name does not match what you expected. Sometimes the autoload works in some scripts but not others, or it works in the editor but fails in exported builds.

Another variant of this problem is calling a method on the autoload and getting Invalid call. Nonexistent function even though the function clearly exists in the autoload script. This usually means you are referencing a different node than you think.

What Causes This

Node name mismatch. The most common cause. When you register an autoload, Godot assigns it a node name in the Autoload settings tab. This node name is what you use to reference it in code. If you registered the script with the node name game_manager but are trying to access GameManager, it will not resolve. The name is case-sensitive and must match exactly.

Confusing class_name with autoload access. Adding class_name GameManager to your script registers a type for use in type hints and the class browser, but it does not make an instance of that class globally accessible. Autoload access is through the node name, not the class name. These are two separate systems in Godot.

The autoload is disabled. The Autoload tab has an Enabled checkbox for each entry. If it is unchecked, the autoload is not added to the scene tree at startup. This can happen accidentally when reorganizing project settings.

Accessing the autoload too early. If a script tries to access an autoload during its own _init() phase, the autoload may not have been added to the tree yet. Autoloads are added in the order they are listed in Project Settings, and they are available starting from _ready() of other nodes.

The Fix

First, open Project → Project Settings → Autoload and verify three things:

1. The script path points to the correct file
2. The node name matches exactly what you use in code (case-sensitive)
3. The Enabled checkbox is checked

Here is a properly configured autoload script and its usage:

# game_manager.gd - The autoload script
extends Node

var score: int = 0
var high_score: int = 0

func add_score(points: int):
    score += points
    if score > high_score:
        high_score = score

func reset():
    score = 0

In Autoload settings, register it with node name GameManager (not game_manager, not Game_Manager). Then access it like this:

# player.gd - Any other script
func collect_coin():
    GameManager.add_score(10)  # Works because node name matches

If you want to use class_name alongside an autoload, you can, but understand they serve different purposes:

# game_manager.gd
class_name GameManagerClass  # For type hints
extends Node

var score: int = 0

# Accessing the autoload (node name, not class_name):
# GameManager.score  ← correct (uses autoload node name)
# GameManagerClass.score  ← wrong (class_name is a type, not an instance)

If you need to access the autoload from _init() or very early in the lifecycle, use a deferred approach:

func _init():
    # Don't access autoloads here - they may not exist yet
    pass

func _ready():
    # Safe to access autoloads here
    GameManager.add_score(0)

Why This Works

Godot’s autoload system works by adding nodes to the root of the scene tree before any other scenes load. These nodes persist across scene changes because they are children of the root, not children of the current scene. When you write GameManager.score in GDScript, the engine looks for a node named GameManager in the autoload scope—not a class, not a file, but a node name.

This is why the node name in Autoload settings is the critical piece. The script file can be named anything. The class_name can be anything. What matters is the node name column in the Autoload table, because that is the identifier Godot registers for global access.

The ordering in the Autoload list also matters. If autoload B depends on autoload A, make sure A is listed above B. Godot initializes autoloads top-to-bottom, so a lower autoload can reference a higher one in its _ready() function, but not the reverse.

Related Issues

If your autoload manages resources that end up shared across instances, see Fix: Godot Resource Sharing Unintended State Between Instances for how to avoid accidental state sharing.

If you are building a multiplayer game and your RPC calls are not reaching other peers, check Fix: Godot Multiplayer RPC Calls Not Reaching Peers for common network configuration issues.

The node name is the contract. Match it exactly.