Product / Godot 4.x / Early access
A production-grade navigation layer for Godot 4.x: TileMap-driven grids, tactical pathfinding, multi-size agents, dynamic blockers, influence maps, Dijkstra maps, flow fields, and editor-first diagnostics for games where movement is gameplay.
Founding Month: pay what you want (suggested $29.99) · then Standard $39 · Studio $149
Live demo
The hero of PathForge is the moment a failed route explains itself: click a stuck agent and read why — required clearance, the changed blocker, the unsynced map state. That "why no path?" panel now has a dedicated playground with editable route data, shareable cases, route JSON, the current Godot development clip, and benchmark data.
Open Playground
Diagnostics playground
The public PathForge workbench is not a product tour. It is a small diagnostic surface for checking how named Godot navigation failures should look when the tool explains them instead of returning an empty array.
Open the editable route workbench with named failure reasons, route JSON, and shareable cases.
Browse the canonical case catalog, then open each failure as a visual playground preset.
Read the narrow Godot 4.6.2 captures and the policy for larger benchmark scenes.
The problem
Godot gives developers useful building blocks: AStarGrid2D, NavigationServer, navigation regions, and enough examples to move something around a map. That is a good beginning. It is also, for many tactical and agent-heavy games, only a beginning.
The awkward part arrives when the game stops asking for "a path" and starts asking for decisions: can a 3x3 unit stand here, how far can this enemy move after AP and terrain costs, what route does a crowd take when lanes change, why did this tower placement break the wave, and which tile is reachable without walking through a unit that is allegedly solid.
PathForge is being developed as a commercial Godot navigation layer for that stage of a project. It does not try to replace all navigation in all genres. That way lies a framework with a logo, a conference talk, and three haunted abstractions. It focuses on grid and tactical navigation first: the part of game AI where the map is discrete, the rules matter, and "why no path?" should have a better answer than silence.
Features
The first useful release is being developed around TileMap and TileMapLayer workflows: generated grids, terrain costs, blocked cells, dynamic blockers, and navigation data that does not have to be maintained in a second secret map.
Tactical RPGs, roguelikes, tower defense games, and simulations need movement ranges, AP costs, reachability maps, terrain penalties, and enemy threat overlays. A shortest path is useful. It is not a design document.
When a route fails, the answer should not be a shrug and an array of coordinates. The current build focuses on blocked-cell inspection, clearance visualization, movement-profile checks, and direct explanations for why no path exists.
The default Godot workflow should stay pleasant. The hot path still needs somewhere serious to go: batched queries, local graph updates, query budgets, cache-friendly data, and an optional Rust GDExtension core when the profiler asks impolitely enough.
AStarGrid2D alternative
AStarGrid2D is a useful Godot API. It is not a bad tool because it has limits. Everything useful has limits; the dishonest tools merely hide them until your release candidate.
PathForge aims at the production gap: TileMap sync, multi-size unit movement, dynamic blocker updates, tactical cost layers, repeatable query performance, and debugging views that make the navigation system observable. The point is not to make pathfinding clever. The point is to make it boring enough to ship.
Production questions
Workflow visuals
Multi-size agents need more than a hopeful A* query. Clearance data makes large units visible to the editor before they wedge themselves into architectural philosophy.
For RTS and crowd-like movement, repeated shortest-path queries become expensive theater. Flow fields give groups a shared direction map instead.
A failed route should explain the failed assumption: blocked cell, insufficient clearance, terrain rule, or dynamic obstacle. Silence is not a debugging strategy.
Use cases
Movement ranges, terrain costs, occupied tiles, large units, and readable overlays for players who want to know why the knight cannot stand on the very important square.
Many agents, repeated queries, flow fields, formations, and path pressure where one hero unit politely walking around a wall is not representative research.
Large maps, many agents, changing buildings, blocked-route diagnostics, and path cache reuse for simulations that produce their own charming emergencies.
Dynamic blocking, route validation, enemy lanes, and editor checks before a player discovers that one tower placement has converted the level into modern sculpture.
Grid movement, changing maps, weighted terrain, reachability, enemy movement choices, and debugging tools for procedural levels that are very proud of their edge cases.
Pricing
For the first 30 days PathForge launches as a Founding Month: pay what you want, suggested $29.99, minimum $0, with the complete V1. After that window, Standard is $39 fixed with a feature-update entitlement, and a Studio / Source / Benchmark tier at $149 adds multi-seat and source/reference access for teams.
30-day launch · suggested $29.99 · min $0
Pay what you want
Fixed, after the founding window
$39
Studio · R&D · comparison
$149
Current pricing reflects the V1 development scope, not a finalized commercial release.
Roadmap
V1 development is centered on the PathForge grid toolkit: TileMap-driven grid generation, reliable grid pathfinding, terrain costs, dynamic blockers, multi-size agents, clearance maps, editor overlays, and a query model that can grow into tactical systems without pretending every game is the same game.
Flow fields, influence maps, formation movement, deterministic helpers, and deeper RTS-scale behavior are queued as Studio and paid-module work. They belong in the product direction, but they should earn their place with real demos and profiler captures, not a feature table that has never met a production map.
Further reading
Godot benchmark
A measured 10,000-agent Godot pathfinding benchmark: per-agent AStarGrid2D queries collapse at 500, while one scheduled shared field scales with JSON evidence.
Godot diagnostics
A diagnostic vocabulary for blocked starts, invalid goals, clearance misses, stale data, and disconnected regions.
Godot pathfinding
A constraint-based decision guide — movement model, dynamism, scale, and path stability.
Godot pathfinding
Where the built-in API stops being enough, and the questions production navigation asks instead.
Godot / Performance
Why navigation shows up as a spike rather than an average, and the scheduling patterns that fix it.
Godot pathfinding
How local invalidation keeps runtime blockers from turning one small map change into a full-grid rebuild.
Godot pathfinding
Why one shared field often beats hundreds of repeated A* queries when a crowd moves toward the same goal.
Godot pathfinding
How one precomputed clearance map lets a single grid route 1×1, 2×2, and 3×3 units correctly.
Godot pathfinding
How a shared field turns a grid from a floor plan into a tactical opinion agents can read.
FAQ
For production grid navigation, that is the intention. AStarGrid2D is useful for prototypes and small systems. PathForge is being developed for projects that need multi-size agents, diagnostics, tactical overlays, and repeated path queries without turning every edge case into custom glue code.
No. A* is one useful algorithm inside the tool. PathForge is being built as a navigation workflow: TileMap-derived grids, terrain costs, dynamic blockers, movement ranges, clearance maps, tactical AI maps, diagnostics, and performance scheduling where the project needs it.
The target is Godot 4.x, with the first production scope aimed at modern Godot 4 releases. The current development target is Godot 4.5+, because supporting old engine behavior forever is how tools become museums with buttons.
For the first 30 days, PathForge launches as a Founding Month: pay what you want, suggested $29.99, minimum $0, and you get the complete V1 either way. After that window, Standard is $39 fixed with a feature-update entitlement, and a Studio / Source / Benchmark tier at $149 adds multi-seat and source/reference access for teams. Paid purchases carry a 30-day money-back guarantee.
The paid tiers are being prepared for commercial use. The final license text will be published before paid release, because surprising customers with license details is a hobby best left to cursed installers.
Yes, multi-size agent pathfinding is one of the main reasons PathForge exists. Clearance maps and editor visualization are being built as first-class features rather than something taped to the side after the first large unit gets stuck in a doorway.
Not in the first Grid-focused release. Volumetric navigation for flying, swimming, drone, and zero-gravity agents is a long-term expansion area, not a V1 promise. The first release is being kept narrow enough to ship and support properly.
Not publicly released yet. PathForge is under heavy development and close to its first public build for Godot 4.x production use. The current V1 work is focused on the problems that usually appear after a navigation prototype survives contact with a real game: multi-size agents, tactical movement constraints, dynamic blockers, repeated path queries, and debugging workflows that do not rely on guesswork. The early access list is open for developers and small studios who want launch updates and a chance to test the first release shape before it becomes fixed.
Early access
Join the early access list for launch notice, pricing updates, and the occasional practical question about what your pathfinding system is currently doing to your frame budget.
