ProLIF: interaction fingerprints for protein-ligand complexes

What ProLIF actually computes

ProLIF, which stands for Protein-Ligand Interaction Fingerprints, is a tool designed to generate interaction fingerprints for complexes made of ligands, protein, DNA or RNA molecules extracted from molecular dynamics trajectories, docking simulations and experimental structures.

The output is the point. An interaction fingerprint is a fixed length vector describing which interactions a ligand makes with its surroundings, so that two structures can be compared numerically. Without it, comparing how a ligand sits in a binding site across fifty snapshots from a trajectory is a manual exercise, and comparing two ligands is a manual exercise multiplied by the number of poses.

So the library sits at the end of a pipeline rather than in the middle of one. It takes structures that already exist, works out the interactions in each one, and produces the descriptors that let the structure set be analysed as data. The README frames it as a tool for generating interaction fingerprints for those complexes, and the package description adds and more, which covers the visualisations and the plugins around it.

The audience is a computational chemist or a structural biologist working with protein-ligand systems, and the topics attached to the repository place it squarely in cheminformatics, drug design, drug discovery and molecular dynamics. The primary language is Python, the licence is Apache 2.0, and the author is Cédric Bouysset, who has been working on it since 2017.

Where the structures come from, and what the reader has to supply

The three sources named in the description are the whole scope of the input side, and it is worth being explicit about what that means.

Molecular dynamics trajectories are the case the library is shaped around. A trajectory produces a long series of snapshots of a complex, and each snapshot can have a different set of interactions, so a fingerprint per frame turns a trajectory into a time series you can plot. Docking simulations give a set of poses with their own variation. Experimental structures give a small number of high resolution snapshots.

In all three cases the input is a structure, and the library's job begins once the structure exists. It does not dock, it does not sample, and it does not refine a pose. That is the first thing to understand about the tool, and it is what separates it from a docking package.

The second thing to understand is the breadth of the partners. The description says the complexes are made of ligands, protein, DNA or RNA molecules, so a fingerprint is not limited to the classic protein-ligand case. A small molecule bound to DNA, or a peptide bound to a protein, goes through the same path.

The repository reflects that the work is centred on analysis rather than packaging. There is a notebooks directory at the top level alongside the prolif package, the tests, the docs and a scripts directory, which is the layout of a library whose primary output is a table you then analyse.

The dependency stack explains the shape of the project

The packaging metadata is the most informative document in the repository, and the dependency list is where the design shows.

dependencies = [
    "pandas>=1.1.0",
    "numpy>=1.13.3",
    "scipy>=1.3.0",
    "mdanalysis>=2.2.0,<3; python_version<'3.13'",
    "mdanalysis>=2.7.0,<3; python_version>='3.13'",
    "networkx>=2.5.0",
    "tqdm",
    "multiprocess",
    "dill",
    "psutil",
    "gemmi>=0.7.5",
]

MDAnalysis is the structure reader, and the version floor depends on the Python version, with 2.2.0 below Python 3.13 and 2.7.0 from 3.13 onwards. That split is a maintenance detail, but it is the kind of detail that catches a user on a fresh interpreter.

The rest of the stack explains the analysis side. pandas and numpy carry the tabular work, scipy and networkx handle the graph and numerical parts, and networkx in particular is the natural fit if a fingerprint is built from a graph of contacts. gemmi is the crystallography format reader, which is how experimental structures get in. tqdm and multiprocess are there for the progress bar and the parallel loop over frames, and dill and psutil are the practical companions of a library that pickles objects and watches its own memory.

RDKit appears in the optional groups rather than the core, in tutorials and in the test group, so the base install does not require it, and the extras are where the plotting and the tutorial notebooks live.

Installation, extras and the documentation first workflow

There is no installation command in the readme itself, and that is not an omission so much as a statement about the project. The instructions, the documentation and the tutorials are said to be found online on ReadTheDocs, at prolif.readthedocs.io, and the readme is a signpost to them rather than a manual.

The distribution channels are visible from the badges. The package is on PyPI as prolif, and it is also on conda-forge, which matters for a scientific audience because conda-forge is where the MDAnalysis and RDKit stack is easiest to install consistently.

The extras are worth understanding before you install. The plots extra pulls in py3Dmol and matplotlib, the tutorials extra adds RDKit, matplotlib, seaborn and pyvis along with the plots extra, and the tests group combines pytest, pytest-cov, ipython and RDKit. The type-check group has mypy, and the docs group pins sphinx at 5.3.0 with myst-nb, sphinx-book-theme and sphinx-autobuild.

For a first use, the sensible order is to install the base package, open the tutorials notebook for the interaction types you care about, and only then decide whether you need the plotting extras. The notebooks directory in the repository is a good sign here, because a fingerprinting tool is easy to use wrongly and hard to use rightly, and a notebook that walks through an actual analysis is more useful than a list of parameters.

One packaging note: the version field in the manifest is 0.0.0, with the real version filled in at build time, so the number you install comes from the release tag rather than from the file you can read.

The engineering around the science

The repository is set up like a project that takes its own correctness seriously, and that matters more here than in most libraries because the outputs are scientific claims.

There is a CI workflow and a separate build workflow, a codecov badge for coverage and a CodeQL badge for code quality, and a .codeql.yml and .codecov.yml in the tree. The presence of a type-check dependency group with mypy says the package is type annotated, and the readme badge row shows MDAnalysis and RDKit as the projects it is powered by, which is a reasonable way for a reader to check the assumptions before installing.

The docs are built with Sphinx at a pinned version, with myst-nb for the notebooks and sphinx-book-theme for the theme, and the sphinx-copybutton and recommark entries suggest the documentation is written for people who will copy code out of it.

There is also a CITATION.cff file and a CHANGELOG.md, and the readme points at a citation page in the documentation. That combination is the professional touch here, and for a tool whose output ends up in a paper it is the part that should not be skipped.

The release cadence is steady. Version 2.2.1 was published on 2026-07-27, 2.2.2 on 2026-09-19 and 2.2.3 on 2026-10-09, with the last push to the default branch on the same day, and the repository is not archived.

Where ProLIF is the wrong tool

Four limits, and the first is the input requirement.

Every path into the library goes through a structure that already exists, which means the hard part of a structure based project, obtaining good quality poses, is not addressed at all. A team whose problem is that the docking is unreliable will not find help here, and the fingerprint output can only be as meaningful as the poses it describes.

The second is the scope of the descriptor. An interaction fingerprint answers a specific question about a specific definition of an interaction, and comparisons across projects are only valid when the definition is the same. There is also a documentation cost here: the tutorials have to be read before the numbers mean anything, and a user who skips that step will get a table of integers with no idea what it encodes.

The third is the Python version split in the MDAnalysis requirement. A user on Python 3.13 or newer resolves a different minimum version of the structure reader than a user on 3.10, which is defensible, and it also means the two environments can behave differently when reading the same trajectory.

The fourth is project shape. This is a library maintained by one person, with a good release rhythm and an unusual amount of documentation care for a project of its size, and the optional groups mean a first install gives you the core and not the visualisations. A team that needs the whole workflow, including the notebooks and the plots, is assembling several environments, and that is worth planning for.

Licence, citation and who to thank

The licence section of the readme is precise. Unless otherwise noted, all files in the directory and all subdirectories are distributed under the Apache License, Version 2.0, with the copyright line reading 2017 to 2026 for Cédric Bouysset, and the full licence text follows in the readme itself.

One detail is easy to miss and worth noting. The ProLIF logo was created by Anton Siomchen and is licensed under the Creative Commons Attribution 4.0 International License, so the code and the artwork are under different terms. That is a common and sensible arrangement, and it also means the logo cannot be reused in a way that assumes the Apache terms cover it. This is not legal advice.

The citation request points at a page in the documentation rather than at a file, and the repository also carries a CITATION.cff, which is the machine readable version that citation tools can pick up.

The project is hosted under the chemosim-lab organisation, the documentation site is prolif.readthedocs.io, and the repository lists the usual routes for problems and questions, with bugs going to the GitHub Issues page and questions and feedback going to GitHub Discussions, with a contribution guide referenced for anyone who wants to work on the code.

Editorial conclusion

ProLIF is the right tool for a computational chemist who has a set of protein-ligand structures and needs a comparable, quantitative description of the interactions in each one, especially across a trajectory where the binding mode changes. It is the wrong tool for generating poses, because it reads structures rather than producing them, and it is the wrong choice for a screen-level library comparison where a simpler descriptor would do. Before adopting, check that the structures you have can be read by the MDAnalysis version your Python resolves to, since the dependency is pinned differently below and above Python 3.13, and read the citation page, because the fingerprint definition has to match the one your comparison expects.

Frequently asked questions

Official sources

1. chemosim-lab/ProLIF on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases