a field-theory motivated approach to computer algebra


See the change log for latest changes only available on github.

Now available: Cadabra in the cloud, from your browser. Email if you want to get access (please provide some details about what you want to use it for).

15 June 2024
Release of 2.5.2 (changes). Cadabra now uses MicroTeX to do the maths typesetting in the notebook interface. This is not only much faster, but also means that LaTeX is no longer a dependency, and we can distribute Cadabra as an AppImage. The GUI has been updated and there are many new features, such as full UTF-8 support, dynamical cell updates and plot animations.
20 Sep 2023
Release of 2.4.4 (changes). Many new features for numerical evaluation and plotting of expressions using nevaluate (see the numerical evaluation chapter in the book) and many bug fixes.
25 Aug 2022
Release of 2.4.0 (changes). Update to accompany the release of the paper about the meld algorithm. Many bug fixes and various functionality improvements and UI enhancements.
21 Nov 2021
Release of 2.3.8 (changes). Update to make Cadabra build on Apple silicon, and many bugfixes and small enhancements throughout.
30 Dec 2020
Release of 2.3.6 (changes). Various bug fixes.

What is Cadabra?

Cadabra is a symbolic computer algebra system (CAS) designed specifically for the solution of problems encountered in field theory. It has extensive functionality for tensor computer algebra, tensor polynomial simplification including multi-term symmetries, fermions and anti-commuting variables, Clifford algebras and Fierz transformations, component computations, implicit coordinate dependence, multiple index types and many more. The input format is a subset of TeX.

Both a command-line and a graphical notebook interface are available, and you can also use Cadabra from Jupyter by using the Cadabra Jupyter kernel.


Cadabra's design philosophy

Cadabra is built around the fact that many computations do not have one single and unique path between the starting point and the end result. When we do computations on paper, we often take bits of an expression apart, do some manipulations on them, stick them back into the main expression, and so on. Often, the manipulations that we do are far from uniquely determined by the problem, and often there is no way even in principle for a computer to figure out what is 'the best' thing to do.

What we need the computer to do, in such a case, is to be good at performing simple but tedious steps, without enforcing on the user how to do a particular computation. In other words, we want the computer algebra system to be a scratchpad, leaving us in control of which steps to take, not forcing us to return to a 'canonical' expression at every stage.

Most existing computer algebra systems allow for this kind of work flow only by requiring to stick clumsy 'inert' or 'hold' arguments onto expressions, by default always 'simplifying' every input to some form they think is best. Cadabra starts from the other end of the spectrum, and as a general rule keeps your expression untouched, unless you explicitly ask for something to be done to it.

Another key issue in the design of symbolic computer algebra systems has always been whether or not there should be a distinction between the 'data language' (the language used to write down mathematical expressions), the 'manipulation language' (the language used to write down what you want to do with those expressions) and the 'implementation language' (the language used to implement algorithms which act on mathematical expressions). Many computer algebra systems take the approach in which these languages are the same (Axiom, Reduce, Sympy) or mostly the same apart from a small core which uses a different implementation language (Mathematica, Maple). The Cadabra project is rooted in the idea that for many applications, it is better to keep a clean distinction between these three languages. Cadabra writes mathematics using LaTeX, is programmable in Python, and is under the hood largely written in C++.


Cadabra was originally written around 2001 to solve a number of problems related to higher-derivative supergravity. It was then expanded and polished, and first saw its public release in 2007. During the years that followed, it became clear that several design decisions were not ideal, such as the use of a custom programming language and the lack of functionality for component computations. Over the course of 2015-2016 a large rewrite took place, which resulted in Cadabra 2.x. This new version is programmable in Python and does both abstract and component computations. This new web site, with new tutorials and all manual pages accessible online, will also hopefully help to make Cadabra easier to use.

Since 2018 Cadabra is available on all major platforms (Linux, MacOS, Windows, BSD). Visit the Q&A forum for help using it.

Copyright © 2001-2024 Kasper Peeters