Credits and licence

Where PlanForge comes from

PlanForge began as a Rust port of Numeric Fast Downward. Numeric Fast Downward is itself a fork of Fast Downward.

So the line of descent has three links, in that order. Naming only the last of them would misdescribe it.

The middle link is the one that matters most. Mainline Fast Downward has no numeric support at all. Numeric fluents, numeric conditions, comparison axioms and the numeric heuristics that most of this planner is made of come from Numeric Fast Downward. Numeric Fast Downward is the direct predecessor, and mainline is its ancestor rather than ours.

The port kept more than an idea. The task representation, the SAS+ translation pipeline, the shape of the statistics block, and several of the numeric heuristics follow the predecessor closely.

The code says so where it matters. Numeric LM-cut, the numeric bounds, the successor generator and the abstraction machinery carry explicit PARITY(numeric-fd) comments. Each one marks a place where the Rust behaviour is deliberately identical to the reference implementation, quirks included. The point of those markers is that a difference in a plan cost can then be attributed rather than guessed at.

Where the two implementations do disagree, the disagreement is treated as a bug in one of them and tracked. It is not quietly normalised away.

Numeric Fast Downward

Numeric Fast Downward is published at github.com/dgnad/numeric-fast-downward. An earlier public tree of the same project is at github.com/Kurorororo/numeric-fast-downward. Both are under the GNU GPL v3.

The particular working tree PlanForge was ported from is a private repository, so it is not linked here. At the file the port follows most closely, it is identical to the second of the two above.

Its history begins with an initial commit by Chiara Piacentini in September 2020 and runs to the end of 2024. By commit count the bulk of the work in that tree is by Ryo Kuroiwa and Daniel Gnad, with further contributions from Eyal Weiss and Misha Gruntov.

That history is squashed. It records who worked on the tree, but not the full authorship of what came before it. So the credit above should be read as the people the repository names, not as a complete author list for numeric Fast Downward as a body of work.

Published work behind the numeric heuristics

These are the references carried in Numeric Fast Downward's own plugin documentation. They are the papers the predecessor's code cites for itself, transcribed rather than inferred.

• C. Piacentini, M. P. Castro, A. A. Ciré and J. C. Beck, "Linear and Integer Programming-Based Heuristics for Cost-Optimal Numeric Planning", AAAI, 2018, pp. 6254-6261.
• C. Piacentini, M. P. Castro, A. A. Ciré and J. C. Beck, "Compiling Optimal Numeric Planning to Mixed Integer Linear Programming", ICAPS, 2018, pp. 383-387.
• E. Scala, P. Haslum, D. Magazzeni and S. Thiébaux, "Landmarks for Numeric Planning Problems", IJCAI, 2017.
• E. Scala, P. Haslum, S. Thiébaux and M. Ramirez, "Subgoaling Techniques for Satisficing and Optimal Numeric Planning", Journal of Artificial Intelligence Research 68, 2020, pp. 691-752.

Not every one of these corresponds to something PlanForge implements. The mixed-integer programming compilations in particular have no counterpart here. They are listed because they are the numeric planning results the predecessor is built on, and the port inherits its design from that work.

Numeric Fast Downward's own source does not name a publication for its numeric LM-cut, which is the heuristic PlanForge follows most closely. So no citation is offered for it here, rather than a guessed one.

What came from current mainline Fast Downward

The translator is not a port of the fork's 2015-era translator. Where mainline Fast Downward has since changed how translation works, PlanForge follows the current design.

The source cites the mainline issues it is matching. issue453 and issue454 are for axiom handling, where every axiom proves its head and default-value axioms move into the SAS task. issue879 is for keeping the order of invariant candidates deterministic, so that the SAS variables do not depend on the run.

The strongly-connected-component analysis is Tarjan's algorithm written iteratively, for the same reason mainline made that change: recursion depth on large tasks.

This is why the translator resembles current Fast Downward more than it resembles the fork it descends from.

What the port changed is the whole of the implementation. There is no C++ and no Python in the pipeline. The PDDL reader, the grounder, the invariant analysis, the search algorithms, the abstractions and the state registry are all Rust.

Several things on this site have no counterpart in either predecessor. The Cartesian abstractions, the saturated cost partitionings and the gradient engine are new here. PlanForge is a derivative work all the same, so it carries its predecessors' copyleft licensing forward, as described below.

People

PlanForge is developed by MRlab, the Machine Reasoning Lab at Linköping University, Sweden.

As recorded in the repository's commit history, the code has been written by Markus Fritzsche and Martín Pozo, with a contribution from Jendrik Seipp. The commit history is the authoritative record. This page will fall out of date before it does.

Publications

The reference for PlanForge itself is its planner abstract for the International Planning Competition 2026, Numeric Tracks.

• M. Fritzsche, M. Pozo, M. Gruntov, A. Shleyfman and D. Gnad, "PlanForge: A Rust Planning Framework for Numeric Planning", planner abstract, International Planning Competition 2026, Numeric Tracks. Abstract, frozen source.

The frozen source is the exact tree the competition ran. It is not this repository, and it does not move. Use it to reproduce a competition result, and use this repository for everything else.

PlanForge entered the simple numeric planning tracks only. The competition and its other entrants are listed on the competition site, and the results were presented at the 36th International Conference on Automated Planning and Scheduling in Dublin.

Prior work the implementation follows

Several components implement published algorithms. Those are other people's results and PlanForge claims none of them.

The citations below are the ones recorded in the source files that implement them, so that a reader can go from a module to the paper it came from. No abstract, figure or passage from any of these works is reproduced here or in the repository.

• The FF heuristic. J. Hoffmann and B. Nebel, "The FF Planning System", Journal of Artificial Intelligence Research, 2001. PlanForge's ff heuristic is this relaxed-plan heuristic.
• Numeric relaxation for FF. J. Hoffmann, "The Metric-FF Planning System", Journal of Artificial Intelligence Research, 2003. The monotonic numeric relaxation follows this work.
• Post-hoc optimisation. F. Pommerening, G. Röger and M. Helmert, "Getting the Most Out of Pattern Databases for Classical Planning", IJCAI, 2013. The posthoc_optimization heuristic solves this linear program over a collection of abstractions built by refinement.
• Split selection for Cartesian abstractions. Schindler, Speck and Helmert, ICAPS, 2026. The icaps26_cartesian abstraction source implements the full-task, first-flaw and desired-region split policies from this paper. The title and the full author names are still to be added. The repository records the authors and the venue but not the title, and it is not guessed here.

Digital object identifiers are not listed for these entries yet. They will be added rather than approximated.

Benchmarks

No benchmark set is shipped with PlanForge or from this site. The PDDL tasks in the repository are regression fixtures with pinned costs, not a benchmark suite.

For classical benchmarks, use Fast Downward's own collection at github.com/aibasel/downward-benchmarks. For numeric domains, go to the numeric tracks of the International Planning Competition. See PDDL support for which of those PlanForge can read.

Licence

The planner

PlanForge is free software under version 3 of the GNU copyleft licences, split by crate. The license field of each crate manifest is authoritative. At the time of writing it is as follows.

In practice: the planner you run is covered by the GPL v3. The library crates you might link into your own project are covered by the LGPL v3, which is the GPL v3 plus additional permissions for linking.

The repository's LICENSE file carries the text of the GNU General Public License v3. The Lesser GPL is defined on top of that text, and both are linked above. If you are deciding what you may do, read the manifest of the crate you actually depend on.

Why it is copyleft

The obligation is inherited, not chosen. Fast Downward is distributed under the GNU General Public License v3. Numeric Fast Downward carries the same licence: its public repositories ship the GPL v3 text and are marked GPL-3.0. PlanForge is a port of that fork.

So the copyleft flows down the whole chain. That is why the table above is GPL and LGPL rather than something more permissive.

One detail, for completeness. The private working tree PlanForge was ported from carries no top-level licence file of its own. The statement above therefore rests on the licence of the public Numeric Fast Downward repositories, which is where that code is published, rather than on a declaration inside the tree itself.

This website

The text, HTML and CSS of this website are released under Creative Commons Attribution 4.0 International, which is CC BY 4.0.

You may copy, quote, translate, adapt and republish them, including commercially, provided you credit the PlanForge project and link back to mrlab.ai/PlanForge. That licence covers the documentation on this site only. It does not cover the planner, which is licensed as above.

Every page loads four files: its own HTML, one stylesheet, the logo and the icon. There is no web font, no stylesheet framework, no JavaScript and no icon set, and nothing is requested from another host. Visiting the site therefore discloses nothing about you to a third party.

The logo is the project's own artwork. The anvil and every letter of the wordmark are hand-drawn paths, so no typeface is involved and none is served to you.

One graphic here is borrowed: the GitHub mark at the top of each page comes from GitHub's Octicons set, under the MIT licence. It is written into the page rather than fetched, so it costs no request and contacts no other host.

Contact

There is no mailing list. Bug reports and patches belong in the issue tracker on the GitHub repository, where they stay visible to everyone.

For anything that does not fit an issue, write to Markus Fritzsche at markus.fritzsche@liu.se, at the Machine Reasoning Lab, or to Martín Pozo at marcosmartin.pozo@uc3m.es, at Universidad Carlos III de Madrid.

A report is easiest to act on when it includes the domain file, the problem file, the exact --search string and the planner's output.