Godot pathfinding & navigation glossary

The vocabulary of Godot navigation, defined in one place: the engine classes, the algorithms, and the production concepts the docs assume you already know. Every definition is Godot-specific and current for Godot 4.6.

A* (A-star): An informed graph search that expands nodes by the lowest f = g + h, where g is the cost from the start and h is a heuristic estimate to the goal. With an admissible heuristic it returns an optimal path. In Godot it is exposed through AStar2D, AStar3D, and AStarGrid2D.
AStarGrid2D: Godot's built-in A* over a rectangular grid of uniform cells. You set its region and cell_size, call update(), then mark cells with set_point_solid() or set_point_weight_scale() (which do not require a further update()), and read a path with get_id_path() or get_point_path(). It has been stable across Godot 4.x. Reference
NavigationServer2D: Godot's navigation-mesh server for continuous 2D space. You query a corridor with map_get_path(map, from, to, optimize), and bake navigation regions rather than working in discrete cells. It is the right tool for free-form movement over mostly-static geometry. Reference
NavigationAgent2D: A node that follows a NavigationServer path and exposes set_target_position() and get_next_path_position() for steering. It is marked Experimental in Godot 4.6, meaning its API may change; pin your Godot version and re-test on upgrades. Reference
NavigationObstacle2D: A node that feeds dynamic avoidance and can carve navigation at runtime. It is marked Experimental in Godot 4.6. A common source of confusion: a plain obstacle affects local avoidance, not the baked path, unless the navigation mesh itself is updated. Reference
Heuristic: An estimate of the remaining cost from a node to the goal. A heuristic is admissible when it never overestimates that cost, which is what guarantees A* optimality. Common grid heuristics are Manhattan, octile, and Euclidean; tie-breaking between equal-f nodes changes which optimal path you get.
Manhattan distance: A grid heuristic equal to |dx| + |dy|. It is admissible when movement is restricted to the four cardinal directions, and overestimates once diagonal moves are allowed, so it suits 4-connected grids.
Octile distance: A grid heuristic for 8-connected grids that prices a diagonal step at roughly 1.414 cells and a straight step at 1. It stays admissible when diagonal movement is allowed, unlike raw Manhattan distance.
Navigation mesh (navmesh): A set of convex polygons describing walkable continuous space. Pathfinding runs over polygon adjacency rather than tile cells, which suits free-form motion. In Godot it is baked into navigation regions and queried through NavigationServer2D/3D.
Grid pathfinding: Pathfinding over discrete tile cells, where each cell is a node and neighbours are adjacent cells. It is explainable, easy to edit at runtime, and a natural fit for tile-based and turn-based games — the domain AStarGrid2D targets.
Dynamic blocker: A runtime object or state change that makes part of the navigation space unavailable: a placed tower, closed door, reservation, destructible wall, or temporary hazard. In grid workflows it is usually a cell or chunk invalidation problem; in navmesh workflows it often becomes a region, obstacle, or rebake policy problem.
Flow field: A precomputed per-cell direction toward a shared goal. The grid is solved once and every agent reads the next direction from its current cell, so a crowd heading to one destination avoids repeating per-agent A*. It is the standard tool for RTS-scale crowds.
Dijkstra map: A scalar field holding the lowest cost from one or many source cells to every other cell, computed by uniform-cost search. Reading the downhill gradient gives movement toward sources; reading uphill gives flee behaviour. It is a staple of roguelike AI.
Clearance: The corridor width a path must guarantee so a larger agent fits. A 3x3 unit needs three contiguous walkable tiles, not just a centre line. AStarGrid2D does not model clearance, which is why oversized units appear to clip through gaps that are too narrow.
Clearance map: A derived grid that stores how much empty space is available from each walkable cell, so a multi-size agent can reject cells it cannot physically occupy with one lookup. It turns footprint validation from repeated geometry checks during A* into precomputed navigation data that can be updated locally when blockers change.
Jump Point Search (JPS): An A* optimization for uniform-cost grids that skips symmetric, equivalent paths by jumping to decision points instead of expanding every cell. It returns the same optimal path as A* while expanding far fewer nodes on open maps.
Influence map: A spatial scalar field that encodes tactical information — threat, control, or desirability — by stamping sources and letting their values fall off over distance. AI reads it to choose where to move, flee, or hold, rather than reasoning unit by unit.
Local avoidance (RVO / ORCA): Per-agent collision avoidance that adjusts velocity to prevent overlap with neighbours, distinct from the global path. Reciprocal Velocity Obstacles and ORCA are the common formulations; in Godot, NavigationAgent avoidance provides this layer on top of a path.

The articles behind these terms

Why is my path failing in Godot? — the empty-path triage checklist, with runnable Godot 4.6 proofs.
Grid or navmesh in Godot? — the AStarGrid2D vs NavigationServer decision, by constraint instead of taste.
Multi-size agents and clearance maps — what clearance means in practice when a 3×3 unit meets a one-cell gap.
Godot 10,000-agent pathfinding benchmark — measured shared-field pathfinding for a crowd, with native JSON and a browser demo.