Jade: Faster and Lighter Co-folding-Ready Homology Search
LiteFold Research ·
You don't need terabytes of binaries to build an MSA.
Jade works through the database one block at a time. It scans each block for seeds, filters out the weak hits, and spends the expensive alignment only where the evidence is strong.
Since the advent of AlphaFold,1 homology search has been an integral part of structure prediction, whether through BLAST or more sophisticated approaches like MMseqs2. However, we have observed that a production MSA search takes a huge amount of storage and requires a lot of prebuilt cache.
This becomes a key bottleneck for several pipelines, including co-folding large atlases and the validation phase of biomolecular design.
That's why, today, we are excited to release Jade: a fast sequence aligner for proteins, DNA, and RNA that does not require a prebuilt index and directly turns its hits into A3M alignments ready for structure prediction and co-folding.
The search builds on the high-throughput alignment ideas pioneered by DIAMOND.2 Jade is the outcome of numerous improvements and optimizations made on top of it. Our key contributions are nucleotide search support, custom CUDA kernels that let the heavy stages run in parallel on the GPU, further optimizations from an auto-research loop, and a ready-to-use workflow for modern co-folding models.
To evaluate Jade, we first simulated a bacterial-genome benchmark, where the default mode reached 99.4% recall on the most diverged queries (30% divergence) in 19.3 seconds, compared with 99.8% in 501.5 seconds for BLASTN. On the SCOP protein benchmark, the GPU / CUDA optimized search brought the sensitive-mode runtime down from 506 seconds on 64 CPU threads to 45 seconds on a single A100 GPU, with the same ROC1 sensitivity. Finally, in a co-folding study on CASP17 targets, Jade built the MSAs for all 32 chains in just 49 seconds, whereas the default AlphaFold 3 search (jackhmmer) takes about 5 to 17 minutes for a single 600-residue chain.3
Jade is currently used in the LiteFold Platform and across our co-folding pipelines, and will soon be available through the LiteFold API and SDK for independent use.
From BLAST to MMseqs2
Homology search is the task of finding sequences in a large database that are evolutionarily related to a query sequence. These hits are what an MSA is built from, and that evolutionary signal is what structure prediction models like AlphaFold rely on.
BLAST made this practical.4 Rather than aligning the query against every sequence in the database, it works in two steps. First, it looks for short matching words between the query and the database, called seeds. They are cheap to find and act as clues that two sequences may be related. Then, it extends only those seeds into full alignments, the slower and more careful step that decides whether the clue actually holds up. This way, the expensive work is spent only where there is some evidence.
Figure: Homology search as a budget. Cheap seed matches propose candidates; only the survivors pay for a full local alignment.
As sequence databases kept growing, BLAST became too slow to be the default for large-scale search. MMseqs2 came into the picture to solve this. It keeps the same seed-and-extend idea, but makes every step much faster, with fast k-mer prefiltering, efficient database representations, and ready workflows for building MSAs.5 When ColabFold replaced the jackhmmer and HHblits search in AlphaFold 26 with MMseqs2, MSA generation became roughly 40 to 60 times faster,7 and it is now what many open structure prediction and co-folding tools use for their MSAs.
But in practice, running MMseqs2 in production comes with a lot of baggage. The ColabFold databases alone need about 940 GB of disk, and the machine needs around 128 GB of RAM for batch searches, going up to 768 GB to 1 TB for fast single-query response.8 On top of that, a search runs through several stages that write temporary files, and all of it has to be downloaded and set up before the first query can run. That is the right trade at enormous batch scale, but for a focused co-folding job, or a pipeline that has to run anywhere, it is more machinery than the question needs.
That is where Jade comes in. We kept the same fast seed-and-extend idea, but made it index-free: Jade reads the database directly and builds the seeds on the fly, so there is nothing to prepare before a search. Protein, DNA, and RNA queries go through one interface, and the protein hits come out as one A3M per chain.
An index still helps when the same nucleotide database is searched again and again. For that, Jade can store the database seeds once in a persistent index and memory-map it on later runs. It does cost disk space: on the 3.8 Gbp benchmark, the fast-mode index is 35 GB and the default-mode index is 70 GB, compared with 44 GB for MMseqs2. Without it, Jade is about 2–3× slower, and for a one-off search there is no need to build it.
How Does Jade Work?
To understand Jade, we first need to understand the engine it is built on. Jade starts from DIAMOND's search, and most of our work went into making it faster and taking it to new places, like nucleotides and GPUs. So before we get to what we changed, let's look at how DIAMOND searches, and how that differs from MMseqs2.
DIAMOND follows the same seed-and-extend idea as BLAST, but it finds the seeds in a different way. Instead of looking up each query word in an index of the database, it builds a list of seeds for both the query and the database, splits both lists by seed, and joins them. This is called double indexing, and it keeps memory access local, which matters a lot at database scale.9
Two more ideas make these seeds work well. The first is that the seeds are spaced: the pattern skips some positions (like 1101101), so a mismatch at a skipped position does not break the seed. The second is a reduced alphabet, where similar amino acids share one letter, like I, L, V and M.10 Together, they let DIAMOND use long seeds and still find distant homologs.
To get more sensitive, DIAMOND simply uses more seed patterns. The default mode uses 2 seed patterns, the sensitive mode 16 and the ultra-sensitive mode 64, and each pattern is one more pass of the join over the database.
Every seed hit is then checked cheaply before any alignment happens. DIAMOND compares the letters around the seed, extends the survivors without gaps, and only then runs a banded SIMD Smith–Waterman alignment on the few that remain. E-values rank the final hits.11
MMseqs2 is also seed-and-extend, but it reaches its candidates differently. It expands every query word into similar words, looks them up in a k-mer index of the database, and keeps a target only when two of those hits fall on the same diagonal. DIAMOND expands nothing. It joins the seeds of the query with the seeds of the database.
Figure: How MMseqs2 and DIAMOND find candidates on the same example. MMseqs2 looks expanded query words up in an index of the database; DIAMOND cuts both sides into seeds and joins them.
This also makes the practical trade-offs different. MMseqs2 usually builds the index of the database ahead of time, so repeated searches are fast, but the index takes storage. DIAMOND builds its seeds on the fly for each block of the database, so there is nothing to prepare, but that work is repeated in every run.
The hardware is the other difference. MMseqs2 has had GPU search since release 16 (November 2024). It needs an NVIDIA Ampere or newer GPU for full speed, runs slower on Turing, and has a preview for AMD GPUs.12 This is not the CPU algorithm moved to a GPU: it uses separate GPU algorithms for gapless filtering and for gapped alignment.13 DIAMOND, to our knowledge, has no official GPU backend. It runs on CPUs, using SIMD instructions and many threads.
A GPU does not automatically make a search faster, though. The result depends on the number of queries, the size of the database, the sensitivity, the hardware and the indexing overhead. So the fair way to compare these tools is at matched sensitivity, by looking at throughput and cost, and not only at run time.
What Jade Adds
Jade keeps DIAMOND's core and its .dmnd database format, and adds two major improvements on top of it.14 First, it adds nucleotide support, so DNA and RNA can be searched the same way as proteins. Second, it adds custom CUDA kernels that run the search in parallel on GPUs.
DIAMOND aligns proteins, and DNA only through translation. For nucleotides, we kept the same search and changed only the parts that depend on the alphabet. Both strands of the query are searched, since a DNA match can lie on either one. Repeats are masked, but only while the seeds are found, so alignments can still extend through them. The seeds are spaced, with a separate set of patterns for each sensitivity level, from 1 pattern for the fastest to 8 for the most sensitive.15 E-values are calibrated for any match and mismatch scoring, and RNA works directly, since U is read as T.16
Figure: What changes for DNA. Each query is searched on both strands, repeats are masked only while seeding, and spaced seeds keep finding a hit when mismatches would break a contiguous one.
The second improvement is the GPU backend. The seed search, the seed filter and the gapped scoring take most of the time in a search, so these are the stages we moved to the GPU, with CUDA kernels written from scratch. Loading, chaining, traceback, E-values and output stay on the CPU.
Figure: Where the work runs in an ultra-sensitive search on one A100. Seed search is the largest stage and runs on the GPU; select a stage to see what it does and how long it takes.
A few design choices matter more than the rest. The first is that the output must be identical to the CPU output. Every kernel is a port of a specific CPU routine, including its integer saturation and the order of its floating-point operations, and not a new implementation of the same idea. We check this with a self-test on millions of random alignments and by comparing the full benchmark outputs byte for byte. When a case is not supported on the GPU, that stage simply runs on the CPU, and the output does not change.
The second is batching. DIAMOND aligns one query at a time, with only a few targets, which is too little work to keep a GPU busy. So the extension threads send their requests to a shared batcher, which launches large batches, and the database block stays on the GPU while it is being searched.
The third is the alignment kernel itself. Scores are kept in half precision, which is exact for integers up to 2,048, with two alignments packed into each register. A group of 8, 16 or 32 threads sweeps the band like a wavefront, and any alignment that reaches 2,048 is redone in 32-bit integers, so the scores are always exact.
Figure: Banded Smith–Waterman only scores the cells around the seed. A narrow band is cheaper, but it can miss an alignment that drifts away from the seed after an insertion or deletion.
The GPU also makes exhaustive search practical for small sets of queries, where every query is aligned against every database sequence without any seeding.17 On one A100, the kernel reaches about 1 trillion cell updates per second, which is 7 times the speed of 64 CPU threads.
The backend needs an NVIDIA GPU with compute capability 8.0 or newer, such as the A100, L40S or H100.18 The backend is not finished, though. In the most sensitive search, the seed kernels still take about half of the time, and most of the rest is CPU work around them, which is what we are working on next.
On top of the search, Jade writes its protein hits as A3M alignments, one per chain, with species pairing for complexes. We cover this in the co-folding section below.
Benchmarks
We benchmarked Jade on nucleotide search, on repeated searches with a persistent index, and on protein search with the GPU backend.
Nucleotide Benchmarks
To measure how fast and how sensitive Jade is on DNA, we built a benchmark from 1,000 complete bacterial genomes (3.8 Gbp). We cut 6,000 fragments of 1 kb out of these genomes and mutated them to a divergence of 5% to 30%, with 10% of the mutations being insertions or deletions. A search counts as successful when it finds the true locus of a fragment, meaning a hit with an E-value of at most 10⁻³ that covers at least half of the locus on the correct strand.19
At the highest divergence of 30%, Jade in its default mode found 99.4% of the loci in 19.3 seconds, whereas BLASTN found 99.8% in 501.5 seconds.20 In its fast mode, Jade found 78.7% in 4.7 seconds, compared with 56.1% in 6.7 seconds for MMseqs2 with k=15.
Figure: Speed and sensitivity on the bacterial genome benchmark. Select a divergence to compare the tools at that level.
The gap grows with divergence. Up to 20%, almost every tool finds almost every locus. Beyond that, the k-mer based tools (megablast, LexicMap, and MMseqs2 at its default k=15) lose recall quickly, while Jade in its default mode stays at 99 to 100% all the way to 30%.
Figure: Recall as the simulated divergence increases. Beyond 20% divergence the fastest k-mer settings lose recall sharply, while Jade default stays near 100%.
Speedups with an Index
To measure the effect of indexing, we ran the fast mode on the same benchmark with and without a persistent seed index. Without an index, Jade rebuilds the seeds of the whole 3.8 Gbp database in every run, and seeding takes most of the time. Using the index reduced the time from 14.4 seconds to 6.5 seconds, and faster database loading brought it down to 4.0 seconds. For comparison, MMseqs2 with k=15 took 6.8 seconds with its own index on the same queries.
Figure: Search time for the fast mode as the index and the database loading improve, next to MMseqs2. Select a bar to see what changed.
Speedups with GPU Enabled
To measure the speedup from the GPU on protein search, we used the SCOP benchmark,21 with 6,370 domain queries against 30.4 million sequences. In the sensitive mode, Jade took 506 seconds on 64 CPU threads and 45 seconds on one A100-80GB GPU, with the ROC1 sensitivity unchanged at 0.347. In the ultra-sensitive mode, it went from 4,416 seconds to 419 seconds, again with the same ROC1 of 0.404. That is a gain of about 11× in the sensitive mode and 10.5× in the ultra-sensitive mode.
For reference, the MMseqs2-GPU paper reports 2,360 seconds on one L40S at a similar ROC1.22 This crosses papers and hardware, so we do not count it as a head-to-head result, and a comparison on the same machine is the right next measurement.
Figure: The same SCOP search on 64 CPU threads and on one A100. The GPU changes the time, not the ROC1.
The exhaustive search, which aligns every query against every database sequence without any seeding, shows the same gain. For 20 SCOP queries against all 30.4 million sequences it takes 86 seconds instead of 409 seconds on 64 CPU cores, with identical results.
From Hits to Co-folding
Fast search matters because it is usually the first step, not the final product. Jade's MSA workflow asks the aligner for the aligned subject sequence, CIGAR string, and coordinates. It reconstructs each hit as an A3M row, writes one MSA per query chain, and can pair chain hits by species for complexes. That pairing is written in the formats Boltz-2 and Protenix read.23 The code supports paired inputs; the reported co-folding results below used unpaired MSAs.
For the first study, we selected 15 CASP17 targets with matching released PDB structures: eight complexes and seven monomers, representing 32 distinct chains.24
Jade searched UniRef50, with 38.8 million sequences, keeping up to 10,000 hits per chain.25 The fast run built all 32 MSAs in 48.9 seconds; default mode took 63.7 seconds.
The resulting MSAs were folded once per target with Boltz-2 and Protenix on one A100-80GB GPU.26
Figure: End-to-end timing per CASP17 target. The small gray segment is MSA preparation; the colored segment is the folding run.
The most practical result is the time split. Jade built the MSAs in about 3.3 to 4.2 seconds per target, while folding took about 80 seconds per target with Boltz-2 and 103 seconds with Protenix. Search is therefore only 3 to 5% of the end-to-end time, so an MSA is cheap enough to regenerate whenever a sequence changes.
On accuracy, the mean TM-score was 0.752 to 0.773 with Boltz-2 and 0.758 to 0.770 with Protenix, and the mean DockQ across the eight complexes was 0.321 to 0.360.27 Several monomers folded very well, while antibody–antigen interfaces were much harder. The median CASP17 group scored higher overall (mean TM-score 0.804 and DockQ 0.382), so the MSA is clearly not the only factor, and more samples, templates, paired MSAs, and a direct MMseqs2 baseline would all matter here.
Figure: TM-score by target for Boltz-2 and Protenix. Switch to DockQ for the eight complexes. The gray marks run from the CASP17 median to the best group; the blue points are the reported Jade folds.
Three things stand out in these results:
- The fast mode is enough for this study. For both models, the difference between fast and default MSAs (±0.02 TM-score) is smaller than typical run-to-run variation. The deeper default MSAs did not change folding time either.
- Monomers sit with the CASP groups. All seven monomers reach TM-scores of roughly 0.90 to 1.00.
- Antibody–antigen complexes remain the hard case. On H2319, H2321, and H2339 every setup scores well below the best CASP groups. Averaged over all 15 targets, our setups sit slightly below the median CASP17 group.
Conclusion and Next Steps
Jade is built on DIAMOND, adds nucleotide search and custom CUDA kernels, and writes its hits directly as A3M alignments for co-folding models. In our benchmarks, the default mode came within half a percent of BLASTN's sensitivity on diverged DNA while running about 26 times faster, and the GPU sped up protein search by 10 to 11 times with the same ROC1. In the CASP17 study, the MSAs for all 32 chains were ready in 49 seconds, which is about 3 to 5% of the end-to-end time with Boltz-2 and Protenix.
These results have limits. The DNA benchmark is simulated, the GPU numbers come from one machine, and the co-folding study is small, with one sample per target and no direct MSA baseline. So the next steps are about making the evidence broader:
- Same-machine baselines. We will compare Jade and MMseqs2-GPU on the same hardware, database, and queries, and compare MSAs from Jade, MMseqs2, and ColabFold on the same co-folding targets, reporting time, memory, disk use, and accuracy together.
- Nucleotide and RNA evaluation. Nucleotide E-values need tighter calibration against decoys and compositionally biased sequences, and the benchmarks should go beyond simulated bacterial genomes to repeat-rich eukaryotic sequence, metagenomes, and real RNA collections.
- Smaller indexes. Seed sampling and less duplication across sensitivity levels could reduce index storage a lot, and we will measure index construction, loading, search, and memory separately.
- Larger co-folding studies. We will test paired and unpaired MSAs, templates, multiple seeds and samples, and a larger target set across CASP16 and the full CASP17 release, with particular attention to antibody–antigen complexes.
- Reproducibility. CPU and GPU outputs will stay covered by regression tests, and every benchmark will ship with its raw tables and end-to-end recipes for Boltz-2 and Protenix.
Our goal is to make MSA preparation cheap enough to repeat whenever a sequence, a scoring choice, or a database changes, so that search can sit inside the same loop as modelling and evaluation.
Footnotes
-
Jumper et al., “Highly accurate protein structure prediction with AlphaFold” (2021): Nature. AlphaFold 3 is described in Abramson et al., “Accurate structure prediction of biomolecular interactions with AlphaFold 3” (2024): Nature. ↩
-
Buchfink, Reuter, and Drost, “Sensitive protein alignments at tree-of-life scale using DIAMOND” (2021): Nature Methods. ↩
-
Measured jackhmmer MSA time for a 602-residue protein in AlphaFold 3's data pipeline: 293 seconds on an NVMe-equipped desktop CPU, up to 1,049 seconds on a cluster file system. See UCSF ChimeraX, “Speeding up AlphaFold 3 MSA calculation” (December 2024). AlphaFold 3 searches larger databases (UniRef90, MGnify, BFD) than the UniRef50 search used here, so this is a reference point rather than a same-database benchmark. ↩
-
Altschul et al., “Basic local alignment search tool” (1990). The core seed-and-extend idea is the historical starting point for this discussion: Journal of Molecular Biology. ↩
-
Steinegger and Soding, “MMseqs2 enables sensitive protein sequence searching for the analysis of massive data sets” (2017): Nature Biotechnology. ↩
-
AlphaFold 2 searched with jackhmmer, from HMMER, and with HHblits. See Eddy, “Accelerated profile HMM searches” (2011): PLoS Computational Biology, and Remmert et al., “HHblits: lightning-fast iterative protein sequence searching by HMM-HMM alignment” (2012): Nature Methods. ↩
-
Mirdita et al., “ColabFold: making protein folding accessible to all” (2022), including its MMseqs2-based MSA workflow: Nature Methods. ↩
-
ColabFold README, “Setting up databases”: 940 GB of storage for the databases, about 128 GB of RAM for batch searches, and 768 GB to 1 TB of RAM for single-query searches against ColabFoldDB: github.com/sokrypton/ColabFold. ↩
-
Buchfink, Xie, and Huson, “Fast and sensitive protein alignment using DIAMOND” (2015), which introduced double indexing: Nature Methods. ↩
-
DIAMOND's default protein modes use the ten-group alphabet of Murphy, Wallqvist, and Levy, “Simplified amino acid alphabets for protein fold recognition and implications for folding” (2000): Protein Engineering. ↩
-
The alignment and significance foundations are Smith and Waterman's local-alignment algorithm (1981) and Karlin and Altschul's statistical theory for local scores (1990). ↩
-
MMseqs2 release 16 (November 2024) introduced GPU-accelerated search, and release 18 (July 2025) extended GPU database creation and packaging. The hardware requirements and the AMD ROCm preview are described in the MMseqs2 README. ↩
-
Kallenborn et al., “GPU-accelerated homology search with MMseqs2” (2025), introduce GPU algorithms for gapless filtering and for gapped alignment: Nature Methods. ↩
-
Jade is developed at github.com/LiteFold/Jade, retains upstream DIAMOND notices and GPLv3 licensing, and is separate from the official DIAMOND project. ↩
-
The patterns were designed with iedera. See Kucherov, Noé, and Roytberg, “A unifying framework for seed sensitivity and its application to subset seeds” (2006): Journal of Bioinformatics and Computational Biology, and Noé, “Best hits of 11110110111: model-free selection and parameter-free sensitivity calculation of spaced seeds” (2017): Algorithms for Molecular Biology. ↩
-
Spaced-seed filtering was popularized by Ma, Tromp, and Li's PatternHunter (2002). The repeat-masking reference is Frith's tantan method (2011). ↩
-
DIAMOND vectorizes full Smith–Waterman alignment with the SWIPE approach of Rognes, “Faster Smith-Waterman database searches with inter-sequence SIMD parallelisation” (2011): BMC Bioinformatics. ↩
-
The GPU backend supports NVIDIA compute capability 8.0 or newer (A100, A10, A30, A40, RTX 30 and 40 series, L4, L40, L40S, H100); unsupported stages or options fall back to the CPU. The documented benchmark configuration used an A100-80GB GPU and 64 CPU threads. See the GPU documentation in the Jade repository. ↩
-
The benchmark also contains 2,000 reversed fragments as decoys. The numbers come from simulated fragments of one bacterial database, so they will differ on other data. ↩
-
BLASTN and megablast are part of BLAST+ (Camacho et al., “BLAST+: architecture and applications” (2009): BMC Bioinformatics), and megablast is described in Zhang et al., “A greedy algorithm for aligning DNA sequences” (2000): Journal of Computational Biology. Discontiguous megablast allows non-consecutive matches in its seed, the idea popularized by PatternHunter. LexicMap is described in Shen, Lees, and Iqbal, “Efficient sequence alignment against millions of prokaryotic genomes with LexicMap” (2025): Nature Biotechnology. ↩
-
The benchmark follows the MMseqs2 evaluation. The queries are SCOP domains (Murzin et al., “SCOP: a structural classification of proteins database for the investigation of sequences and structures” (1995): Journal of Molecular Biology), and ROC1 is the area under the ROC curve up to the first false positive, a measure introduced for sequence search by Gribskov and Robinson (1996): Computers & Chemistry. ↩
-
Kallenborn et al., “GPU-accelerated homology search with MMseqs2” (2025), reports the published GPU baseline and hardware context used for this cross-paper comparison: Nature Methods. ↩
-
A3M is part of the HH-suite alignment ecosystem. The accepted paired and unpaired layouts are documented by the official Boltz and Protenix projects. ↩
-
CASP17 is the 2026 community experiment for independent assessment of structure-prediction methods; its schedule, targets, and evaluation process are maintained by the Prediction Center. ↩
-
Suzek et al., “UniRef clusters: a comprehensive and scalable alternative for improving sequence similarity searches” (2015): Bioinformatics. ↩
-
Model references: Passaro et al., “Boltz-2” (2025), and the Protenix Team, “Protenix-v1” (2026). ↩
-
TM-score was introduced by Zhang and Skolnick for global structure similarity (Proteins, 2004); DockQ combines interface and ligand/receptor RMSD measures into a continuous complex-quality score (Basu and Wallner, 2016). ↩