A* Pathfinding in Godot and Unity: Free Starter Projects

The direct answer

Use the GDScript download with the Standard Godot editor, the Godot C# download with the .NET editor, or the Unity C# download for an explicit Unity grid. Each free MIT-licensed project opens to a real authored scene with blocked terrain, a visible A* route, one destination, and an agent that follows the returned cells.

No plugin, account, or installer is required. Extract the ZIP, open the listed scene, press Play, and click another open cell. The blue pocket near the top-right exercises the deliberate no-path branch; the source and Inspector fields remain available for the first change.

What the three downloads give you

All three projects use a 15 × 9 grid with the same recognizable wall layout, start cell, default destination, and isolated no-path cell. The scene APIs and coordinate conversions are native to each engine. Exact source structure and exact route tie-breaking do not need to match.

• Walkable and blocked terrain.
• One agent and one destination marker.
• A visible route drawn over the grid.
• Click-to-change destination input.
• Movement along the returned cell anchors.
• Reset without reopening the project.
• An intentionally unreachable target.
• A verifier that checks both the pure search and the runnable scene.
• A README and an MIT license inside the ZIP.

What to change first

Start with the authored scene and its controller before changing the search. A different terrain layout should not require rewriting the heap, and a different path color should not change path legality.

The A* baseline used by the downloads

The grid gives every legal cardinal step a cost of 1. The heuristic is Manhattan distance: abs(goal.x - cell.x) + abs(goal.y - cell.y). The stable binary min-heap orders frontier entries by known path cost plus estimated remaining cost.

For each improved neighbor, the search records the new cost and its parent. When the goal is popped, following those parents back to the start produces the cell path. An invalid, blocked, or unreachable endpoint returns an empty path.

This baseline is intentionally plain. It gives you one complete loop to modify without introducing terrain weights, diagonals, smoothing, or engine navigation services at the same time.

Every code block below is copied from the exact hash-bound file in its download, with only the surrounding class or function indentation removed.

A* pathfinding in Godot with GDScript

Open project.godot with the Standard Godot 4.7.1 editor. The project starts at res://scenes/articles/astar_starter_gdscript.tscn. The authored hierarchy contains separate Board, PathLine, PathDots, Agent, Goal, and UI nodes. Small @tool renderers keep the board, route, and markers visible in the 2D editor before the game runs.

The scene controller converts the click to a grid cell, calls AStarGrid.find_path(), updates the existing path nodes, and advances the agent from one returned anchor to the next. Press R to restore the initial route. Clicking the blue pocket near the top-right produces the visible no-path state.

The machine-readable receipt records Godot 4.7.1-stable, the source hashes, nine workspace checks, the scene smoke, and the extracted-package rerun that becomes the tenth public check.

while not frontier.is_empty():
	var entry: Dictionary = frontier.pop()
	var current: Vector2i = entry.get("cell", Vector2i(-1, -1))
	var current_cost := int(entry.get("path_cost", UNREACHED_COST))
	if closed.has(current):
		continue
	if current_cost != int(cost_so_far.get(current, UNREACHED_COST)):
		continue
	if current == goal:
		return _reconstruct_path(came_from, start, goal)

	closed[current] = true
	for direction: Vector2i in CARDINAL_DIRECTIONS:
		var neighbor := current + direction
		if not _is_in_bounds(neighbor, grid_size):
			continue
		if blocked.has(neighbor) or closed.has(neighbor):
			continue

		var candidate_cost := current_cost + 1
		if candidate_cost >= int(cost_so_far.get(neighbor, UNREACHED_COST)):
			continue

		cost_so_far[neighbor] = candidate_cost
		came_from[neighbor] = current
		var priority := candidate_cost + manhattan_distance(neighbor, goal)
		frontier.push(neighbor, priority, candidate_cost)

A* pathfinding in Godot with C# and .NET

Use the Godot 4.7.1 .NET editor, not the Standard-only build. The project targets net8.0; restore and build it with an installed .NET SDK 8 or later, then open res://scenes/AStarStarterCSharp.tscn.

The .tscn is fully authored. Its [Tool] board and marker scripts keep the scene readable in the 2D editor, while runtime state stays in AStarStarterController.cs. The pure search is in Scripts/AStarGrid.cs.

The verifier restored and built the project with zero warnings and zero errors, then loaded the real scene through the Godot .NET editor. The receipt also records the net8.0 target and a green movement/no-path scene smoke.

Godot 4 C# projects do not support Web export. Choose the GDScript starter if a browser build is part of your next step.

public bool SetDestination(Vector2I cell)
{
    if (!IsInBounds(cell))
    {
        ShowNoPath(cell, "Destination is outside the grid");
        return false;
    }

    var blocked = BlockedCells();
    if (blocked.Contains(cell))
    {
        ShowNoPath(cell, "That destination is blocked");
        return false;
    }

    _agent.Position = CellCenter(_agentCell);
    _goalCell = cell;
    _goal.Position = CellCenter(_goalCell);
    _path = AStarGrid.FindPath(_board.GridSize, blocked, _agentCell, _goalCell);
    _pathIndex = 1;
    _noPathVisible = _path.Count == 0;
    _moving = _path.Count > 1;
    UpdatePathNodes();

    if (_path.Count == 0)
        SetStatus($"No path to {FormatCell(_goalCell)}", true);
    else if (_path.Count == 1)
        SetStatus($"Already at {FormatCell(_goalCell)}", false);
    else
        SetStatus($"Path: {_path.Count - 1} steps • moving", false);

    return _path.Count > 0;
}

A* pathfinding in Unity with C#

Open the source project with Unity 6000.5.1f1, then open Assets/AStarStarter/Scenes/AStarStarterUnity.unity.

The Unity scene is serialized before Play. Its hierarchy contains 135 terrain cells, 23 blocked cells, 80 reusable path segments, 81 path dots, an agent, the destination, controls, and status UI. The runtime updates those existing objects; it does not create the base demonstration after you press Play.

Press Play and click any open cell. TRY UNREACHABLE GOAL exercises the empty-path branch; RESET SCENE or R restores the initial state.

The PlayMode suite contains eight synchronous search checks and one real-scene test. The clean extracted ZIP repeated the same suite. The receipt records all ten public checks and the final scene hash.

private void UpdatePathObjects()
{
    for (var index = 0; index < pathDots.Count; index++)
    {
        var active = index < _path.Count;
        pathDots[index].gameObject.SetActive(active);
        if (active)
            pathDots[index].anchoredPosition = CellCenter(_path[index]);
    }

    for (var index = 0; index < pathSegments.Count; index++)
    {
        var active = index < _path.Count - 1;
        pathSegments[index].gameObject.SetActive(active);
        if (!active)
            continue;

        var from = CellCenter(_path[index]);
        var to = CellCenter(_path[index + 1]);
        var delta = to - from;
        pathSegments[index].anchoredPosition = (from + to) * 0.5f;
        pathSegments[index].sizeDelta = new Vector2(delta.magnitude + 6.0f, 6.0f);
        pathSegments[index].localRotation = Quaternion.Euler(
            0.0f,
            0.0f,
            Mathf.Atan2(delta.y, delta.x) * Mathf.Rad2Deg);
    }
}

Add the next pathfinding feature

The projects stop at a four-neighbor, unit-cost baseline. Choose the next guide from the gameplay rule you need to add, not from the name of another algorithm.

When to use the engine's navigation system instead

The downloadable projects are useful when the cell graph is part of the game's rules or part of what you are learning. They are not a reason to ignore a suitable navmesh workflow.

For grounded 3D movement over floors, ramps, and platforms, use the verified Godot 3D pathfinding starter: it covers the saved bake, NavigationAgent3D movement loop, click targets, and the boundary between a navmesh and AStar3D.

What the verification proves

The receipts do not establish performance, engine ranking, code-size superiority, exact output parity, or suitability for every project.

Measurement-gap: these starter projects publish correctness and authored-scene checks, not a cross-engine performance benchmark. Runtime speed depends on the graph, workload, engine integration, and the changes you make after download.