# FORM: symbolic algebra where the expression size is bounded by disk, not RAM

> FORM is a symbolic manipulation system written in C, authored by Jos Vermaseren of NIKHEF, whose defining property is that expression size is limited by available disk space rather than memory, with a pattern-matching language built for algebraic transformation. It suits high energy physics calculations and anyone manipulating very large symbolic expressions, and it is the wrong tool for numeric work or for a casual computer algebra need.

**form-dev/form** — The FORM project for symbolic manipulation of very big expressions

- Repository: https://github.com/form-dev/form
- Stars: 1,244 · Forks: 155
- Language: C
- License: GPL-3.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/form-dev-form

## The landmark feature is that expressions live on disk

FORM is a Symbolic Manipulation System. It reads symbolic expressions from files, executes symbolic and algebraic transformations on them, and returns the answers in a textual mathematical representation. The property the README calls its landmark feature is that the size of the considered expressions is limited only by available disk space and not by available RAM. That single design decision explains most of what makes FORM different from a general computer algebra system. When a physicist expands a trace over many indices, the intermediate expression can be larger than memory, and a system that must hold everything in RAM simply fails at that point. FORM was built for exactly that case, and the README states that it has been essential for many state-of-the-art computations in high energy physics.

## The input language is a pattern matcher, not a function call

The two quick examples in the README show what working in FORM actually feels like. The first declares a symbol, builds a local expression E equal to x^10, and then repeatedly matches the power of x in E as long as the power is more than 1, creating two new terms with lower power, before printing the result, which is E = 34 + 55*x.

```form
Symbol x,n;
Local E = x^10;

repeat id x^n?{>1} = x^(n-1) + x^(n-2);

Print;
.end
```

The second matches a function f with any arguments before an x and any arguments after, and swaps them around, starting from f(1,2,x,3,4) and producing f(3,4,1,2).

```form
CFunction f;
Symbol x;
Local E = f(1,2,x,3,4);

id f(?a,x,?b) = f(?b,?a);

Print;
.end
```

The id statement is the core primitive. It finds every subexpression matching the left-hand pattern and replaces it with the right-hand side, and the ?a and ?b wildcards capture the parts that differ between matches. A condition such as ?{>1} can be attached to a pattern to restrict which matches count.

## The program format is its own little language

A FORM file is a sequence of declarations and statements terminated by .end. Symbols and functions are declared with Symbol and CFunction, expressions are bound to names with Local, and the transformations are applied with id and repeat. Print outputs the current expression in the textual mathematical form, which is what a physicist then reads, diffs or pastes into a paper. This is not an interactive shell in the way a modern CAS is, and that is a deliberate trade. You write a program, run it, and it prints results. The consequence is that a computation is a reproducible file rather than a session state, which is a genuine advantage in a research setting where a calculation may be rerun months later with one term changed.

## Building needs autoconf and make, and the optional libraries change what you get

The build is a standard autotools flow. The README advises installing autoconf and automake, cloning the repository, then running autoreconf, configure, make and make install.

```sh
autoreconf -i
./configure
make
make install
```

Before that, it is advised to install the optional dependencies gmp, mpfr, zstd, zlib and flint for better performance. The distinction that matters is stated explicitly: to use arbitrary-precision floating-point arithmetic, both gmp and mpfr are required, and if either is unavailable that feature is simply not enabled. So the difference between a build with and without those two libraries is not a matter of degree, it is whether a whole category of arithmetic exists. The zstd and zlib libraries and flint matter for compression and for number-theoretic work respectively, and the INSTALL file in the repository root covers more advanced build options.

## A prebuilt binary on PyPI removes the compiler from the path

For anyone who wants to try FORM without a build toolchain, the README notes that a pre-compiled binary can be installed from PyPI, under the form-bin package name. That is a small but significant practical point, because FORM is otherwise a C project with an autotools build and a set of optional native dependencies, and that combination is exactly where a first-time user loses an afternoon. The PyPI route sidesteps autoconf, automake and the GMP and MPFR question entirely, though it also means the package you get is the one the maintainer built rather than one you built, which matters if you intended to enable optional features. The repository root shows the surrounding structure of the project, with sources/, extern/, doc/, scripts/, a check/ directory and a Makefile.am driven by configure.ac and m4/.

## One author, a long lineage, and a permissive reading of the licence

FORM's original author is Jos Vermaseren of NIKHEF, the Dutch institute for subatomic physics, and the README points to an AUTHORS file for everyone else who has contributed. The licence is GPL-3.0, with the copying and licensing information in the COPYING file, and the README says that information can be found there rather than restating it. The practical consequence for an organisation is the usual one for a GPL codebase: a distributed modified version carries source obligations, while using FORM as a tool to produce results does not. Since FORM's own output is mathematical expressions rather than a linked library, most research use falls on the safe side of that line. The project is the official upstream at github.com/form-dev/form, with the source site at nikhef.nl and an active issue tracker and discussion forum.

## Release notes live on the wiki, and 5.0 is a recent major line

Documentation is spread across the wiki and a hosted manual, and the README gives the three places worth bookmarking. The release notes for the current line are on the FORM 5.0 wiki page, the reference manual is published at form-dev.github.io under the stable path, and the FORM Cookbook on the wiki collects worked programs. Background material, a collection of FORM programs and a number of courses are on the official website. The tag history shows 5.0.2 on 2026-09-18, 5.0.1 on 2026-06-24 and 5.0.0 on 2026-01-27, so the 5.0 branch has been receiving point releases through the year, and the last push to the repository was on 2026-10-13. The project also runs a test workflow and coverage reporting in continuous integration, visible as badges in the README.

## Conclusion

FORM is worth adopting for symbolic work where expressions outgrow available memory, since its disk-bounded storage model and pattern matching language have made it essential for state-of-the-art high energy physics computations, and the v5.0 series has recent releases. It is not a fit for numeric computation, where a specialised CAS with an arbitrary-precision numeric core is a better choice, nor for a team that wants a modern interactive notebook workflow. Verify first which optional dependencies you can install, since gmp and mpfr together are required to enable arbitrary-precision floating point and are disabled if either is missing, and read the 5.0 release notes on the wiki before upgrading across the major version.

## FAQ

### What is FORM and who uses it?

FORM is a Symbolic Manipulation System that reads symbolic expressions from files and executes algebraic transformations on them, returning textual mathematical output. The README states it has been essential for many state-of-the-art computations in high energy physics, and its original author is Jos Vermaseren of NIKHEF.

### How do I build FORM from source?

Install autoconf and automake, clone the repository, then run autoreconf -i, ./configure, make and make install. Optional dependencies gmp, mpfr, zstd, zlib and flint improve performance, and gmp together with mpfr are required for arbitrary-precision floating point.

### Can I install FORM without compiling it?

Yes. The README says a pre-compiled FORM binary can be installed from PyPI under the form-bin package name, which avoids needing autoconf, automake and the native optional libraries.

### What is the difference between FORM and an ordinary computer algebra system?

The README identifies the landmark feature: the size of the expressions FORM considers is limited only by available disk space and not by available RAM. It is a program-oriented system driven by pattern matching statements such as id and repeat rather than an interactive session.

## Sources

- [form-dev/form on GitHub](https://github.com/form-dev/form)
- [Issues](https://github.com/form-dev/form/issues)
- [License: GPL-3.0](https://github.com/form-dev/form/blob/master/LICENSE)
- [README](https://github.com/form-dev/form/blob/master/README.md)
- [Releases](https://github.com/form-dev/form/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/form-dev-form