Catlab.jl and applied category theory in the Julia language

A framework for categorical structure, not for proofs

Catlab.jl is described as a framework for applied and computational category theory, written in Julia, and it provides a programming library and interactive interface for applications of category theory to scientific and engineering fields. It emphasizes monoidal categories due to their wide applicability, but can support any categorical structure that is formalizable as a generalized algebraic theory.

The list of what Catlab is not is the most useful part of the readme, and it is stated with unusual directness. Catlab is not an automated theorem prover, because although there is some overlap between computer algebra and automated theorem proving, it does not produce formal certificates of correctness. It is not a proof assistant, because it does not produce formally verifiable proofs, and formal verification is explicitly not within the scope of the project. And it is not a graphical user interface, because it does not provide a wiring diagram editor or other graphical user interface; it is primarily a programming library, not a user-facing application.

That list is what makes the project honest about itself, and it also tells you where the boundary is. If your goal is to check a mathematical claim, Catlab is the wrong instrument, and no amount of adoption will change that. If your goal is to model a system compositionally, represent wiring, or manipulate expressions symbolically with algebraic laws attached, then it is aimed directly at that.

The framework describes itself as being, or eventually being, three things, and the careful wording matters. It is a programming library first and foremost. It can also be used interactively in Jupyter notebooks. And it will serve as a computer algebra system for categorical algebra, where the distinguishing feature is that all expressions are typed using a fragment of dependent type theory called generalized algebraic theories.

That last point is the heart of the project. The type system is not a set of Julia structs with fields; it is a formalisation of the algebraic laws that a structure obeys, and the laws are what the algorithms exploit.

Wiring diagrams are the thing it is best at

Wiring diagrams, also known as string diagrams, are supported through specialized data structures and can be serialized to and from GraphML, an XML-based format, and JSON.

That is the concrete, practical half of the library, and it is worth being clear about why it exists. A wiring diagram is a picture of how things are composed, and in the applied setting it is how you describe a pipeline, a signal flow, a dataflow or a physical arrangement of components. Drawing one by hand in a general purpose diagram tool means the composition structure is only a picture, and a picture cannot be composed, optimised, or checked.

The difference with a categorical representation is that the structure is data. A wiring diagram held as a data structure can be traversed, rewritten, and serialised, and a diagram drawn in a general purpose tool cannot. That is the case for the specialized data structures.

The interactive side is the second half of the story. Symbolic expressions are displayed using LaTeX, and wiring diagrams are visualized using Compose.jl, Graphviz or TikZ. So the workflow is to build the diagram programmatically and then look at it, rather than draw it and then try to describe it.

The repository layout backs this up. There is a `src/` directory, a `test/` directory, a `docs/` directory, a `benchmark/` directory, an `ext/` directory for Julia package extensions, and a `Project.toml` at the root, which is how a Julia package declares its dependencies and its compatible version range.

The Julia CI/CD badge, the codecov coverage badge and the presence of a `benchmark/` directory all point to a project with a real test and performance practice behind it, which is unusual for a research library and worth noting.

Macros give you a syntax for specifying a doctrine

The library's approach to syntax comes from macros, and the readme is precise about what they are for. Macros offer a convenient syntax for specifying categorical doctrines and type-safe symbolic manipulation systems.

A doctrine in this setting is a specification of which algebraic laws a structure obeys, and the macro machinery is how you write that specification down in Julia rather than constructing it by hand at run time. The type-safe part is what makes the approach different from a generic symbolic engine, because the type system carries the laws, and the laws are what the rewriting algorithms know how to apply.

That design is why the project is not a general purpose computer algebra system. In the world of classical abstract algebra, the readme points you elsewhere, to AbstractAlgebra.jl and Nemo.jl. Catlab is doing the same kind of work, with the same idea of core algorithms for solving word problems and reducing expressions to normal form, but with respect to several important doctrines, such as those of categories and of symmetric monoidal categories.

The upstream project is a general one: AlgebraicJulia, and the site is algebraicjulia.org, with a DOI registered for the project. The project also maintains other packages in the same ecosystem, and the readme points to Semagrams.jl for the graphical user interfaces that Catlab deliberately does not provide, covering interaction with wiring diagrams, Petri nets and the like.

So the ecosystem division is: Catlab for the data structures and the algebra, Semagrams.jl for the visual editing.

Where to get it, and what the documentation does and does not give you

There is no install command in the repository readme, which reflects how a Julia package is normally obtained rather than an omission: the package is registered in the General registry and added to a project environment as a dependency, with the `Project.toml` at the root of this repository holding the package's own name, version and dependency list.

What the readme does give you is the documentation location and an honest statement about it. The documentation contains several example notebooks, as well as partial API docs, and the project readily acknowledges that the documentation is not as well developed as it should be. The invitation to ask questions follows, with the Julia Zulip `#catlab.jl` stream given as the preferred venue and a `#catlab` channel on the Julia Slack marked as less preferred.

That admission is worth taking at face value when you evaluate. A framework whose value is in its type system and its macros is exactly the kind of framework where API documentation matters, because the type-level API is not discoverable by reading function signatures. If you are not going to read the source, the notebooks are what you have, and the project says so.

The contributing side is more encouraging. Applied category theory is described as a young and growing field, and Catlab as the subject of ongoing research and development, which means there are lots of opportunities to do new and interesting things. Contributions are welcome regardless of your experience level with category theory or with the Julia language, and the CONTRIBUTING file has the details.

The project is MIT licensed, the default branch is `main`, and the most recent releases are v0.17.4 on 2025-12-17, v0.17.5 on 2026-03-23 and v0.17.6 on 2026-06-10, with the last push on 2026-07-02.

A research library is the wrong thing to put in production

There are three situations where Catlab is the wrong choice, and the honest one is the first.

The first is a production service. The readme describes a subject of ongoing research and development, and the version numbers carry the evidence: the last three releases are v0.17.4, v0.17.5 and v0.17.6, a pre-1.0 line with a patch release every few months. That is normal and healthy for a research library. It is a poor foundation for a system with an uptime commitment.

The second is a workflow that needs proofs. The distinction the readme draws is precise: Catlab cannot be considered a theorem prover because it does not produce formal certificates of correctness, and formal verification is not within the scope of the project. If your task is to establish that a computation is correct in a formal sense, you need a proof assistant, and the readme is telling you not to use Catlab for that.

The third is a team that does not need category theory. The type system is built on generalized algebraic theories, a fragment of dependent type theory, and the macros exist to specify categorical doctrines. A team that wants to model a pipeline in a more conventional way, with ordinary Julia types and a graph library, would be paying for machinery they do not use. The library's value is proportional to how much structure it lets you express, and if the answer is not much, the learning cost dominates.

There is a smaller operational consideration. The `ext/` directory at the root is the Julia mechanism for package extensions, which let optional dependencies be loaded only when they are used, and the `benchmark/` directory indicates the project cares about the performance of its own algorithms. Both are signs of a well built package, and neither removes the constraint that this is a research tool in a moving field.

Editorial conclusion

Catlab.jl fits an applied mathematician or a domain modeller who needs to represent composition, wiring and categorical structure symbolically and wants to serialise the result, and who is comfortable in Julia. It is the wrong choice for a verification workflow, because the project states that formal verification is out of scope, and it is the wrong choice for a production service, since it is a research library in a young field. Before adopting, verify three things: how much category theory you actually need, since the type system is built on generalized algebraic theories and not on plain Julia types, whether the documentation gap described in the readme is acceptable for your team, given that the project readily acknowledges it is not as well developed as it should be, and which of the three faces of the project you want, library, notebook or computer algebra system, since the readme describes them as things Catlab is or will eventually be. The code is MIT licensed, the last push was on 2026-07-02, and the most recent release is v0.17.6 from 2026-06-10.

Frequently asked questions

Official sources

1. AlgebraicJulia/Catlab.jl on GitHub
2. License: MIT
3. Project website
4. README
5. Releases