Product / Godot 4.5+ / Early access
A navigation layer for games where movement is gameplay: tactical grids, multi-size units, dynamic blockers, and editor-visible failure reasons.
Founding Month: pay what you want (suggested $29.99) · then Standard $39 · Studio $149
Last updated 2026-08-21 · first public build target: September 2026
What is PathForge?
PathForge is a Godot 4 navigation addon by Vav Labs, with the first public build targeted for September 2026. It adds multi-size agent clearance, dynamic blockers, tactical movement, and editor diagnostics on top of Godot's built-in navigation. V1 targets Godot 4.5+. The public Playground and benchmark repository are available now.
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, validation artifacts, and benchmark data.
The 10,000-agent benchmark behind the performance claims is public: clone the GitHub repo and reproduce it.
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.
Play a complete Godot maze chase and cycle through the live Dijkstra field used by each hunter.
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. 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 profiling shows the need.
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 single-cell A* assumptions. Clearance data makes large units visible to the editor before they enter invalid spaces.
For RTS and crowd-like movement, repeated shortest-path queries get expensive quickly. 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
Still choosing between an explicit grid, graph, navmesh, or shared field? Use the complete game-pathfinding guide first.
Movement ranges, terrain costs, occupied tiles, large units, and readable overlays for players who need clear movement rules.
Many agents, repeated queries, flow fields, formations, and path pressure where a single-agent path is not enough evidence.
Large maps, many agents, changing buildings, blocked-route diagnostics, and path cache reuse for long-running simulations.
Dynamic blocking, route validation, enemy lanes, and editor checks before one tower placement breaks the route.
Grid movement, changing maps, weighted terrain, reachability, enemy movement choices, and debugging tools for procedural levels.
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 written before validation.
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.
GitHub benchmark repo
Runnable Godot source for the scheduled shared-field benchmark, with scripts for native JSON captures.
Godot diagnostics
A diagnostic vocabulary for blocked starts, invalid goals, clearance misses, stale data, and disconnected regions.
Godot tools
A source-checked inventory of Godot 4 pathfinding addons and GitHub projects, with a neutral disclosure of the broader production-workflow gap PathForge is being built around.
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.
FAQ
PathForge is a Godot 4 navigation addon by Vav Labs. It adds multi-size agent clearance, dynamic blockers, tactical movement, and editor diagnostics on top of Godot's built-in navigation. V1 targets Godot 4.5+. The public Playground and benchmark repository are available now.
Not publicly released yet. The first public build is targeted for September 2026. 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.
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+.
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.
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.
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.
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.
More Godot tools
Project hygiene · Free & MIT
Scan broken references, oversized textures, heavy scenes, and export gaps in the editor or CI.
Energy shield VFX · €5
A reactive Godot 4 shield shader with layered projectile hits, sustained beams, custom meshes, and full source.
