LocalColabFold: the AlphaFold notebook as a script you can run on your own GPU

The scope is batch prediction, not looking up a structure

The project states the recommendation plainly, and it is the first thing a reader should take in. If you only intend to predict a small number of naturally occurring proteins, the documentation suggests using the ColabFold notebook or downloading structures from the AlphaFold Protein Structure Database or UniProt. LocalColabFold is suitable for more advanced applications, such as batch processing of structure predictions for natural complexes, non-natural proteins, or predictions with manually specified MSAs and templates.

So the case for running this locally is not convenience, it is a specific class of problem. The notebook runs one prediction at a time in a hosted environment with a time limit, and the upstream notebook carries the 90 minute and 12 hour timeouts that the advantages list calls out as removed here.

What the project describes itself as is an installer script designed to make ColabFold functionality available on users' local machines, supporting Windows 10 or later through the Windows Subsystem for Linux 2, macOS and Linux. The phrase ColabFold on your local PC is the whole proposition: the upstream ColabFold repository is the real product, and this is the packaging that makes it installable.

The advantages are listed as four points. Structure inference and relaxation will be accelerated if the machine has an Nvidia GPU and CUDA drivers. There is no time out of 90 minutes and 12 hours. There are no GPU limitations. And it is not necessary to prepare the large database required for native AlphaFold2, because the search step that ColabFold normally does against the remote database is replaced by a locally built one.

That last point is the one people underestimate. The ColabFold notebook depends on a hosted MSA and template search service, and a local installation replaces it with a local database and a local colabfold_search, which is what makes offline operation possible at all.

The environment is declared in the manifest, and that is the design

Since January 2026 the project has used pixi to install localcolabfold, and the pyproject.toml in the repository root is now the real specification of the environment.

The package metadata is short. The name is localcolabfold, the version is 1.6.1, the description is ColabFold on your local PC, and requires-python is pinned to exactly ==3.12.12, an exact patch version rather than a floor. The pixi workspace declares channels of conda-forge and bioconda, and platforms of linux-64, linux-aarch64 and osx-arm64.

The per-target dependency lists are where the interesting differences sit, and they are worth reading closely because they show what each platform can and cannot do.

The conda dependencies are the same on all three: openmm pinned to 8.2.0 for the relaxation step, pdbfixer at 1.10, kalign2 at 2.04, hhsuite at 3.3.0, mmseqs2 and numpy held at or below 2.1.3, plus git.

The PyTorch side is where the platforms diverge. On linux-64 and linux-aarch64, jax is pinned to 0.10.1 with the cuda12 extra, tensorflow to 2.21.0, tqdm to 4.66.1 and silence_tensorflow to 1.2.3, and colabfold is pulled from git with the alphafold-minus-jax extra.

On osx-arm64 the comment in the manifest is explicit: no GPU support, because jax-metal 0.1.1 does not work well with ColabFold because of a multiprocessing.resource_tracker issue, and there jax is pinned back to 0.5.0.

That is a real constraint for anyone on an M-series Mac, and it is stated in the repository rather than in a support answer somewhere. The Apple Silicon target runs the CPU path with an older jax, and the CUDA acceleration that the advantages list promises is a Linux NVIDIA feature only.

Installing on Linux is a pixi install and a setup script

The Linux path is the one the documentation is written around, with Ubuntu 22.04 or later recommended.

The prerequisites are modest for a scientific tool: curl, git and wget, installed with sudo apt -y install curl git wget if they are missing. Then the CUDA compiler driver, which must be 11.8 or later with 12.4 preferable, and the documentation is careful to say to check it with nvcc --version and not with nvidia-smi.

Then pixi itself, installed with:

curl -fsSL https://pixi.sh/install.sh | sh

And then the repository and the installation script:

git clone https://github.com/yoshitakamo/localcolabfold.git
cd localcolabfold
pixi install && pixi run setup

The installation lands in the .pixi/envs/default/ directory inside the cloned repository, so the environment is not installed system wide. That matters for a tool with a heavy dependency stack, because it means you can delete the clone and the environment with it, and it means two checkouts can carry different versions of the same stack without interfering.

The documentation then points at the sample script, run_colabfoldbatch_sample.sh, which runs colabfold_batch, with a note to set the correct PATH in the shell script, pointing at the bin directory of the pixi environment. The prediction itself is started with:

bash run_colabfoldbatch_sample.sh

The environment variables block that follows is for the memory and allocation settings on the GPU path, with TF_FORCE_UNIFIED_MEMORY, XLA_PYTHON_CLIENT_MEM_FRACTION, XLA_PYTHON_CLIENT_ALLOCATOR and TF_FORCE_GPU_ALLOW_GROWTH.

The WSL2 case is a filesystem problem, not a Linux problem

The Windows path goes through WSL2, and the documentation has a caution that is worth reading before you start rather than after.

If the installation fails due to symbolic link creation issues, the cause given is that the Windows file system is case-insensitive while the Linux file system is case-sensitive. The fix is to enable case sensitivity on the install directory, run from Windows PowerShell rather than from inside WSL:

fsutil file SetCaseSensitiveInfo path\to\localcolabfold\installation enable

The path in the command is a placeholder, and the instruction is to replace it with the path to the directory where LocalColabFold is being installed.

The underlying issue is that the ColabFold and AlphaFold stacks create symbolic links during setup, and a case-insensitive mount cannot represent them correctly. Enabling per-directory case sensitivity is the documented workaround, and it has to be applied before the install runs, not after it fails.

This is the kind of detail that separates a project which has actually been installed on Windows from one that has only been documented. The README also says to use the ColabFold notebook or the AlphaFold database for the simple cases, which is a sensible escape route for anyone who hits this and does not need the local feature set.

The model choice is automatic unless you override it

There is a note about the model type that removes a common source of confusion, and it is one of the better things in the documentation.

The note says that colabfold_batch will automatically detect whether the prediction is for monomeric or complex prediction, and that in most cases users do not have to add the model type flag to turn on multimer prediction. The alphafold2_multimer_v1 and alphafold2_multimer_v2 models are also available, and the default is auto, which uses alphafold2_ptm for monomers and alphafold2_multimer_v3 for complexes.

So the defaults are sensible and the older multimer versions remain available for people who need to reproduce a specific earlier result.

The repository layout shows the shape of the project more clearly than the prose does. At the top level there is the install_colabbatch_linux.sh script, the run_colabfoldbatch_sample.sh sample, a pyproject.toml, a LICENSE and the README, plus a 1BJP_1.fasta file and a 1.0.0 directory. There is also a v1.5.5_old_installers/ directory, which tells you that the installation method changed at version 1.5.5 and the old installers are kept for reference.

That matters for anyone following an older tutorial. The May 2024 note says the current GPU-supported jax above 0.4.26 requires CUDA 12.1 or later and cudnn 9, and recommends upgrading or installing the CUDA driver and cudnn with CUDA 12.4 preferred. The January 2024 note says ColabFold upgraded to 1.5.5, which is compatible with AlphaFold 2.3.2, and that LocalColabFold now requires CUDA 12.1 or later.

The version floor has therefore moved twice in the documentation, and the January 2026 entry adds pixi as the supported install path. Anyone picking this up should read those notes rather than a tutorial written in 2023.

Offline operation depends on building the databases yourself

The January 2024 note contains the change that made local use practical, and it is easy to miss because it is buried in a release list.

Now LocalColabFold can predict protein structures without connecting to the Internet. The setup_databases.sh script from the ColabFold repository is used to download and build the databases, and the documentation points at the ColabFold downloads page for the data itself. There is also a note that an instruction to run colabfold_search to obtain the MSA and templates locally is written in a specific comment in the ColabFold issue tracker.

That is the crux of the design. The ColabFold notebook works by sending a sequence to a remote search service that returns the multiple sequence alignment and the structural templates, and the model runs on the free hosted GPU. A local installation replaces the first step with a local database and the second step with your own GPU, and the two replacements are why the advantages list mentions both no GPU limitations and no need to prepare the large database required for native AlphaFold2.

The database build is also the slowest and largest part of a local setup, and the cost is disk rather than time. The documentation points at the ColabFold downloads site for the data rather than describing a build procedure, which means the size and the build time of that database are properties of the upstream ColabFold project and change with it.

There is a related point about the AlphaFold parameters. The December 2021 note says that LocalColabFold became compatible with the latest pip installable ColabFold, and that in this repository the author provides a script to install ColabFold with some external parameter files to perform relaxation with AMBER, and that the weight parameters of AlphaFold and AlphaFold-Multimer are downloaded automatically at first run.

So the weights arrive on first use and the databases arrive on setup, and between them a local installation becomes genuinely self-contained.

Where LocalColabFold is the wrong choice

Three situations rule it out.

The first is a handful of naturally occurring proteins, and this is the upstream recommendation rather than an opinion. The ColabFold notebook does the same job for a single sequence with none of the setup, and the AlphaFold Protein Structure Database and UniProt already hold predicted structures for much of the known protein universe, so running the model yourself for a sequence that has already been solved is work without a result.

The second is a machine without a recent NVIDIA GPU. The advantages are conditional on having an Nvidia GPU and CUDA drivers, and the whole point of running locally rather than in a notebook is the hardware you already own. On Apple Silicon the manifest itself says there is no GPU support, because of a multiprocessing resource tracker problem with jax-metal, and jax is pinned back to 0.5.0 there. A CPU-only Linux box will run the predictions, slowly, and the installation still expects a CUDA compiler driver check in the documented flow.

The third is a team that wants ColabFold to move forward automatically. This project is an installer and an environment definition, so it inherits ColabFold's pace, and the version history shows that: the pinned ColabFold release is 1.5.5, which the January 2024 note calls compatible with AlphaFold 2.3.2, while the manifest itself now says version 1.6.1 and pulls colabfold from git with the alphafold-minus-jax extra. A project that wants the newest upstream model behaviour should track ColabFold directly rather than through this wrapper.

The licence is MIT, which is permissive for a scientific tool and means you can modify the scripts for your own cluster without restriction. The last push to the repository was on 2026-07-01 and the most recent tagged release listed is v1.5.5 from 2024-01-30, so the git history rather than the release list is where the current state is described.

Editorial conclusion

LocalColabFold fits a structural biology group that needs batch structure prediction on its own hardware, whether for natural complexes, non-natural proteins or predictions with manually specified MSAs and templates, and it is also the practical route to running ColabFold without a network connection once the databases are built. It is the wrong choice if you only need a handful of naturally occurring proteins, because the upstream README recommends the ColabFold notebook or the AlphaFold Protein Structure Database for exactly that case, and it is the wrong choice if you cannot supply a GPU with a recent CUDA driver, since the accelerator path is where the value is. Before installing, read the version notes in the README, because the CUDA requirement has moved repeatedly, and check the pixi platform list in the project manifest against your machine, since the Apple Silicon target is configured without GPU support.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. YoshitakaMo/localcolabfold on GitHub