Overview

krepp is a k-mer-based tool for searching and finding query sequences in large reference genome collections, estimating the distance between reads and reference genomes, and placing them on backbone phylogenies and/or taxonomies. It uses locality-sensitive hashing (LSH), a phylogeny-guided k-mer coloring algorithm, and a maximum-likelihood framework to achieve these.

What we will cover

This tutorial walks through the core krepp workflow using a controlled mock microbial community consisting of 20 marine genomes simulated at 100,000 Illumina reads. We will work with two small reference sets to avoid heavy computation during the tutorial. We will index one toy reference set with controlled novelty and limited relatedness to queries and directly download another, diverse but heavily down-sampled microbial index.

The tutorial consists of five main sections:

1. Installation of the tools and downloading the tutorial datasets.
2. Indexing reference genomes and using one of the available pre-built indexes.
3. Estimating read-to-genome distances and interpretation of distances.
4. Placing reads on a reference phylogeny (or a taxonomy) and visualising the result with gappa.
5. Exercises with a more realistic reference index and conclusions.

Resources

• Slides for the first part of this tutorial.
• The main paper (Genome Biology) with methodological details and extensive benchmarking.
• Another tutorial (in IMSI, 2025) for an earlier version which remains mostly valid.
• Slides (from RECOMB 2025) focusing on method and results.

Setup

Hardware requirements

Participants should have access to a machine with at least 8 GB of RAM and 8 GB of free disk space. You can either run the tutorial on your personal laptop, or use a remote server that you have access to. Some commands we will run may benefit from a multi-threaded setup, but this is only optional.

Software requirements

We will be using krepp version v0.8.2.

We recommend using micromamba, refer to this link for installation.

Create an environment and install krepp

Set up an environment and install krepp (version 0.8.2) via Bioconda, then verify the installation:

micromamba create -n krepp-tutorial -c conda-forge -c bioconda krepp=0.8.2 -ymicromamba activate krepp-tutorialkrepp --help

krepp version: v0.8.2krepp: a tool for k-mer-based search, distance estimation & phylogenetic placement.Usage: krepp [OPTIONS] SUBCOMMANDOptions:--help--verbose,--no-verbose{false}                            Increased verbosity and progress report.--seed UINT                 Random seed for the LSH and other parts that require randomness. [0]--num-threads UINT          Number of threads to use in OpenMP-based parallelism. [1]Subcommands:index                       Build an index from k-mers of reference genomes.place                       Place queries on a tree with respect to an index.dist                        Estimate distances of queries to genomes in an index.inspect                     Display statistics and information for a given index.sketch                      Create a sketch from k-mers in a single FASTA/FASTQ file.seek                        Seek query sequences in a sketch and estimate distances.

Install helper tools into the same environment, and verify:

micromamba install -c conda-forge -c bioconda gappa=0.9.0 wget -ygappa --help

                                            ....      ....                                            '' '||.   .||'                                                ||  ||                                                '|.|'    ...'   ....   ... ...  ... ...   ....        .|'|.    |  ||  '' .||   ||'  ||  ||'  || '' .||      .|'  ||    |''   .|' ||   ||    |  ||    | .|' ||     .|'|.  ||    '....  '|..'|'. ||...'   ||...'  '|..'|.    '||'    ||:.    '....'          ||       ||                ''''     ''''   v0.9.0 (c) 2017-2025                                by Lucas Czech and Pierre BarberaUsage: gappa [OPTIONS] SUBCOMMANDOptions:--help FLAG                 Print this help message and exit.--version FLAG              Print the gappa version and exit.Subcommands:analyze                     Commands for analyzing and comparing placement data, that is, finding differences and patterns.edit                        Commands for editing and manipulating files like jplace, fasta or newick.examine                     Commands for examining, visualizing, and tabulating information in placement data.prepare                     Commands for preparing and preprocessing of phylogenetic and placement data.simulate                    Commands for random generation of phylogenetic and placement data.tools                       Auxiliary commands of gappa.gappa - a toolkit for analyzing and visualizing phylogenetic (placement) data

Download and prepare the tutorial data

git clone https://github.com/bo1929/ismb2026-krepp-tutorial-materials.gitcd ismb2026-krepp-tutorial-materialsbash scripts/setup.sh

Verify the inputs are ready

ls data/

input_map.tsvindex-WoLv1-tiny/profile.tsvprofile_species_accessions.tsvquery_genomes/query_info.tsvquery_taxonomy.tsvquery_mixture.fq.gzreference_genomes/reference_info.tsvreference_taxonomy.tsvreference_tree.nwk

Dataset

Query mixture of reads

• A controlled (mock) metagenomic sample: 100,000 simulated Illumina reads from 20 query genomes.
• The mixture is based on an abundance profile mimicking a marine environment.
• Queries in this mixture differ in terms of abundances, taxonomies, and their novelty level.

Abundances of queries and taxonomic profiles

• Spanning two kingdoms, Bacteria (83%) and Archaea (17%), and seven classes:
  • Gammaproteobacteria (~66%)
  • Thermoprotei (~11%)
  • Alphaproteobacteria (~8%)
  • Thermococci (~6%)
  • Epsilonproteobacteria (~5%)
  • Acidimicrobiia (~2%)
  • Deinococci (~2%)

Reference genomes and novelty levels

To see how a certain taxon can be identified depending on its representation in a reference database, we control its novelty level by measuring the lowest shared taxon of the closest reference genome.

As it will be discussed in the next section in more detail, we will be using two different sets of reference genomes:

• a 31-genome toy reference set for controlled novelty,
• a small but diverse microbial index (Web of Life) spanning many taxa.

For the Web of Life, we do not control the novelty but we do for the toy reference set. Some queries match a reference at species rank (same taxon, different individual genomes). Others share only genus, family, or kingdom with their best matching reference, in terms of the ANI between them, akin to the phylogenetic distance measured in branch lengths.

By novelty-level (the lowest shared taxonomic rank with the closest reference):

• species: 11 queries (33% of reads)
• genus: 6 queries (53% of reads)
• family: 1 query (2% of reads)
• kingdom: 2 queries (13% of reads)

Figure 1. Dataset overview. Left: What portion of the query reads relates to the toy reference set by novelty, then kingdom and class level abundances. Right: All 20 query species with relative abundances (coloured by class).

Reference genome set

• References cover two kingdoms (Bacteria and Archaea), five phyla (Proteobacteria, Actinobacteria, Deinococcus-Thermus, Crenarchaeota, and Euryarchaeota), and seven classes (Gammaproteobacteria, Alphaproteobacteria, Epsilonproteobacteria, Acidimicrobiia, Deinococci, Thermoprotei, and Thermococci).
• Below we show a phylogeny consisting of both reference genomes and query genomes.
• Novelty of each query can also be understood as the branch length to the closest reference in this phylogeny.
• We will use a similar phylogeny after excluding the queries for phylogenetic placement of the reads in the query mixture.

Figure 2. A toy phylogeny built using Mash distances and neighbor-joining, queries are colored in red. Although this may not be the most reliable method for obtaining a microbial phylogeny (as Mash distances do not extend well to highly divergent genomes, which we have in our case), it is good enough for our purposes. The same species may appear at tips both as query and reference, which correspond to queries that are least novel (another genome from the exact same species is present in the reference).

Goals

• Abundant and low-novelty query reads should be identified correctly with low distances.
• High novelty reads should be mapped correctly to corresponding references but with potentially high distances.
• Rare and low-abundance queries should be detected with correct abundances.
• Phylogenetic placement should associate queries with correct branches, reflecting the overall composition at a higher resolution than a taxonomy.

Summary table

Indexing reference genomes

Whether you have a collection of reference genomes or prefer a public database, krepp expects them to be indexed using locality-sensitive hashing. An index is simply a directory storing certain data structures in binary format, together with a human-readable metadata file.

The krepp command-line interface offers a subcommand called krepp index that builds an index from a collection of reference genomes.

Indexing genomes from scratch

Input files

Given a set of reference genomes, krepp builds an index via krepp index -o /path/to/index -i /path/to/input.tsv.

There are only two required options:

• -o (--index-dir), which is the output directory path in which the index will be stored,
• -i (--input-file) a two-column TSV file mapping reference IDs to paths/URLs for FASTA/Q files (gzip compatible).

Each reference (whether a complete assembly or a genome skim) is a file identified by a unique ID. The input map links these IDs to their file paths using a two-column, tab-separated format: REF-ID<TAB>/path/to/ref. The paths can be either absolute or relative to the current working directory.

For the toy dataset, the input map can be seen below:

head -5 data/input_map.tsv

Pyrodictium_occultum    data/reference_genomes/GCF_000007085.1.fna.gzThermus_thermophilus    data/reference_genomes/GCF_000006785.2.fna.gzAllochromatium_vinosum  data/reference_genomes/GCF_900119735.1.fna.gzCandidatus_Endolissoclinum_sp   data/reference_genomes/GCA_965228445.1.fna.gzPsychrobacter_cryohalolentis    data/reference_genomes/GCF_000013905.1.fna.gz

Building the index

Run from inside data so paths in input_map.tsv resolve.

cd datakrepp index \    -i input_map.tsv \    -o toy-index \    --num-threads 4cd ..

krepp version: v0.8.2Invocation: krepp index -i input_map.tsv -o toy-index --num-threads 4Tue May 26 05:20:01 2026Reading the tree and initializing the index...No tree has given as a guide, the color index could be suboptimal.Building the index...Internal node: 60   size: 13408544  progress: 61/61Finished indexing, elapsed: 19.8957 secSkipped saving a backbone for the index!Done converting & saving, elapsed: 0.069542 secTue May 26 05:20:21 2026

You will, of course, have different dates and exact elapsed times.

Inspecting and verifying an index

We can verify an index by running

krepp inspect -i data/toy-index | head -n 16

Backbone tree: NA======= Partial index: 0 =======krepp version: v0.8.2date: 2026-05-26 05:27:50seed: 0k: 29w: 35h: 13m: 4frac: trueppos_v: [28, 26, 25, 22, 16, 14, 12, 11, 7, 5, 4, 3, 1]npos_v: [0, 2, 6, 8, 9, 10, 13, 15, 17, 18, 19, 20, 21, 23, 24, 27]nrows: 33554432total_num_kmers: 13408544sdust-t: 0sdust-w: 0

This command also reports the parameters used during indexing for future reference. Alternatively, to display similar information about the index, we can check the metadata file.

cat data/toy-index/metadata-*.txt

(Optional) Indexing options and parameters

If you only want to test different parameters and options without overwriting the existing index, use a different -o directory.

krepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 2 --no-frackrepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 1 --no-frackrepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 0 --no-frac

krepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 2 --frac

krepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 3 --no-frackrepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r 4 --no-frac

seq 3 99 | xargs -I{} -P4 \    krepp index -o /path/to/index -i /path/to/input.tsv -t /path/to/tree.nwk -m 100 -r {} --no-frac

krepp index \    -i input_map.tsv \    -o toy-index \    -t reference_tree.nwk \    --num-threads 4

Installing pre-built indexes

We will use the Web of Life index (tiny version <2 GB) which includes a microbial phylogeny (>10,000 leaves).

wget --no-check-certificate https://ter-trees.ucsd.edu/data/krepp/index-WoLv1-tiny.tarmkdir -p datatar -xf index-WoLv1-tiny.tar -C data/

The downloaded directory contains the index. This particular index is small enough to fit in your laptop's memory.

Run cat data/index-WoLv1-tiny/metadata-*.txt to see the configuration and verify the download.

krepp version: v0.8.2date: 2026-05-29 04:53:32seed: 0k: 27w: 33h: 12m: 36frac: falseppos_v: [26, 25, 24, 22, 21, 17, 14, 8, 7, 5, 3, 2]npos_v: [0, 1, 4, 6, 9, 10, 11, 12, 13, 15, 16, 18, 19, 20, 23]nrows: 466034total_num_kmers: 184716530sdust-t: 0sdust-w: 0

See this page for the full list of available databases.

Distance Estimation: krepp dist

• krepp dist computes the Hamming distance between individual sequences (e.g., short reads in our case) in a given FASTA/Q file and sufficiently similar (i.e., <25% similarity) reference genomes in the index.
• These approximate distances are akin to alignment identity: If you were to align this read (e.g., using Bowtie2), the proportion of mismatches is expected to match krepp's distance estimates.
• Individual estimates for reads may have some error, especially at high distances (>15%), but they are accurate on average, and can recover genome-wide similarities.
• These distances are the main information krepp relies on for various tasks such as phylogenetic placement, taxonomic classification, and for providing sample-wise (i.e., for the entire file) summaries.

Per-read distances (default)

By default, krepp reports distances between individual sequences and all relevant references:

krepp dist -i data/toy-index -q data/query_mixture.fq.gz --num-threads 4 > results/distances_default.tsv

The output is in a tab-separated format, consisting of three columns:

• SEQ_ID: sequence/read identifier in the input
• REFERENCE_NAME: name of the matching reference in the index
• DIST: estimated maximum likelihood distance

head results/distances_default.tsv

# software: krepp       version: v0.8.2 invocation :krepp dist -i data/toy-index -q data/query_mixture.fq.gz --num-threads 4 -o results/distances_default.tsvSEQ_ID  REFERENCE_NAME  DISTNC_007484.1-37612   Nitrosococcus_oceani    0.00009NC_007484.1-37612   Nitrosococcus_wardiae   0.20504NC_007484.1-37612   Nitrosococcus_watsonii  0.07074NC_013960.1-34342   Nitrosococcus_oceani    0.18942NC_013960.1-34342   Nitrosococcus_wardiae   0.11605NC_008818.1-42619   NA  NaNNC_021291.1-872 Spiribacter_roseus  0.20522NC_009663.1-23622   NA  NaN

Some observations:

• The exact order of the rows may change across reads, but the mappings should be identical.
• Notice that a sequence identifier may appear across multiple consecutive rows; this means that the corresponding read is mapped to multiple references, each with its own distance.
• The number of unique IDs in the first column is equal to the number of reads in the given query file.
• Some rows could have NA, indicating that there is no reference that could be matched for this particular read.

Other options for distance estimation

Filtering reference hits

By default, krepp reports all reference hits, regardless of their distances.

If you are only interested in references that are sufficiently close compared to the best match, use --filter flag:

krepp dist -i data/toy-index -q data/query_mixture.fq.gz --num-threads 4 \    --filter -o results/distances_filtered.tsv

For each read, this only retains mappings that are not too far away from the reference hit with the minimum distance.

• Another option is to keep only the one with the best match (lowest distance) using --no-multi (default: --multi).
• Alternatively, one can directly cap at a maximum distance threshold (e.g., 5%) using --dist-max 0.05.

Run krepp dist --help to list all options and see their descriptions.

Interpretation of results

Figure 3. Distribution of per-read krepp distances, grouped by the novelty level of the source query genome. Species-level queries (the index contains another genome of the exact same species) have distances centred near zero (mean 0.034) with a high mapping rate (81%). Queries with genus-level novelty are spread much more widely, with mean and median both well above 0.1, as expected. Family and kingdom-level queries have much lower mapping rates, reflecting the absence of any close relative in the reference set, and are biased towards reads from more conserved regions. Mapped reads with distances saturating near 0.20 also demonstrate the limits of sensitivity (at least in this setting with only a few references and a toy index).

Figure 4. Genome-wide distance (measured by Mash) vs. average per-read distance measured by krepp for each query organism's closest reference genome. Left: top-5 species-level queries by mapping rate. Pairs cluster tightly near the diagonal at distances below 2%, showing close agreement between krepp per-read estimates and whole-genome Mash distances. Right: top-5 genus-level queries, for which krepp means track Mash distances across a wider range (0.10–0.27). Nitrosococcus halophilus hits N. wardiae at exactly 0.0953 on both axes. However, at very high genome-wide distances, krepp starts to underestimate due to the large portion of reads that are not mapped, and also due to mapping bias towards reads that come from more conserved regions. Bottom: mapping rate (fraction of reads with at least 1 hit) for the same 10 organisms, ranging from 99.9% (Alteromonas macleodii) down to 12.6% (Palaeococcus pacificus).

Counting operational genomic units

• Instead of retaining the per-read distance estimation, one could summarize the entire query file (i.e., a sample) in operational genomic units (OGUs).
• Although the interpretation is different from taxonomic abundance profiles, an OGU table provides a useful high-level view on the entire composition.
• Each read is counted as 1, and its contribution to each genomic unit (i.e., a single reference) is disproportional to the number of equally good matches.
• With --summarize, krepp internally sets --filter. Then, for each read, it counts the number of reference hits (call it n), each getting an equal share (1/n). The reported result is an OGU table.

krepp dist -i data/toy-index -q data/query_mixture.fq.gz --summarize --num-threads 4 \    > results/distances_summary.tsv && head results/distances_summary.tsv

Phylogenetic Placement: krepp place

• krepp place uses distance estimates to find placements on a given phylogeny that best explain the distances for each query.
• For each query sequence (e.g., a read), after finding reference hits and estimating ML distances, krepp looks for large clades in the phylogeny that are indistinguishable from the minimum-distance leaf (i.e., closest reference genome).
• In this mode, a reference phylogeny must be provided via the -t option; its tip labels must match the reference IDs in the input file (-i) used during indexing.
• If a guide tree was provided during indexing, krepp uses that tree for placement unless it is overridden via -t.

Incorporating the relationships between reference genomes into the analysis, phylogenetic placement provides a more interpretable and complete view of the queries.

Placing reads on a phylogeny

By default, krepp reports multiple placements for each query, weighted by likelihood ratios, and filters out placements with only a few k-mer matches (i.e., low evidence).

For a given backbone phylogeny in Newick format (data/reference_tree.nwk), run:

krepp place -i data/toy-index -q data/query_mixture.fq.gz \    -t data/reference_tree.nwk --num-threads 4 -o results/placements_default.jplace

which reports placement in a .jplace file, which is a JSON-based format used to encode phylogenetic placements as a set of records containing branch, distance, and uncertainty information per read, together with the reference tree.

head results/placements_default.jplace

Visualization and interpretation of placements

You may rightfully hesitate to get your hands dirty and write your own scripts for analyzing .jplace files. Luckily, gappa (a tool we downloaded during the setup step) offers solutions for a good collection of tasks and post-processing needs, one of which is visualizing placements as a heat-tree (similar to a heat-map) from the .jplace outputs, coloring branches by the total placement mass they accumulate:

gappa examine heat-tree \    --jplace-path results/placements_default.jplace --mass-norm relative \    --write-svg-tree --out-dir results/ --file-prefix heat_ --allow-file-overwriting \    --svg-tree-shape rectangular --svg-tree-ladderize --svg-tree-stroke-width 3

Figure 5. Heat-tree generated by the above command, showing per-branch placement mass (proportion of placements). Notice that a high mass has been placed within the Nitrosococcus clade, reflecting the high abundance queries Nitrosococcus halophilus (17.5%) and Nitrosococcus oceani (5.7%). Similar observations can be made for Spiribacter roseus and Spiribacter salinus. Overall, phylogenetic placements are in agreement with the input query abundances.

Some observations:

• Queries with a reference from the same species place predominantly on the terminal branch of the closest reference, with LWR near 1.0 and short placement distances (~0.002–0.02). The read is close enough to the reference genome that no other branch is competitive.
• Queries with genus-level novelty spread their mass across multiple terminal branches within the genus clade and onto the internal branch connecting them. For example, Nitrosococcus halophilus reads contribute mass across N. wardiae, N. oceani, N. watsonii, and the internal edge joining them. krepp correctly localises the read within the genus but cannot resolve it to a single species as it is not present.
• More novel queries tend to place either on deep internal branches or incorrectly on distant terminal branches, usually with low LWR spread across many edges. The placement distances are high (>0.15), and no single branch dominates. This correctly signals that the query diverges above the genus level and that the reference set lacks a close relative.

Other placement options and formats

• For a flat and more readable view, krepp can also report placements in a table format, using --tabular:

  krepp place -i data/toy-index -q data/query_mixture.fq.gz \    -t data/reference_tree.nwk --tabular --num-threads 4 > results/placements_tabular.tsvhead results/placements_tabular.tsv

• To aggregate placements across all reads into per-branch abundances, use the --summarize option:

  krepp place -i data/toy-index -q data/query_mixture.fq.gz \    -t data/reference_tree.nwk --summarize --num-threads 4 > results/placements_summarized.tsv

Placing on a taxonomy

• In addition to a phylogenetic tree, krepp can also place sequences on a taxonomy (which is a multi-furcating tree without branch lengths) using the same branch length agnostic placement algorithm.
• For taxonomic placement, krepp requires a tab-separated lineage file (-l) mapping each reference name to a semicolon-separated GTDB-style path (e.g., XYZ k__Bacteria;p__Proteobacteria;...;s__Escherichia coli, see an example here).
• The -t (tree) and -l (lineage) flags are mutually exclusive: use -l with the path to the lineage file for a taxonomy-based placement and -t with the path to the Newick file for phylogenetic placement.

XYZ k__Bacteria; p__Chloroflexota; c__; o__; f__; g__Roseiflexus; s__ABC k__Bacteria; p__Chloroflexota; c__; o__; f__; g__Chloroflexus; s__Chloroflexus aurantiacus123 k__Bacteria; p__Chloroflexota; c__; o__; f__; g__Thermomicrobium; s__Thermomicrobium roseumA00 k__Bacteria; p__Chloroflexota; c__; o__; f__; g__Dehalococcoides; s__Dehalococcoides mccartyiA11 k__Bacteria; p__Chloroflexota; c__; o__; f__; g__Dehalococcoides; s__Dehalococcoides mccartyi

krepp place -i data/toy-index -q data/query_mixture.fq.gz -l data/reference_taxonomy_lineages.tsv \    --tabular -o results/taxplacements_tabular.tsvhead results/taxplacements_tabular.tsv | grep -v "#"

SEQ_ID  DISTAL_NODE EDGE_NUM    LWR DISTNC_015559.1-12009   Marinomonas_posidonica  37  1.00000 0.08579NC_015559.1-3949    Marinomonas_posidonica  37  1.00000 0.13930NC_022664.1-43244   Spiribacter 57      0.47172 0.14497NC_022664.1-43244   Spiribacter_roseus  53  0.52828 0.12986NC_011312.1-6343    Aliivibrio_salmonicida  13  1.00000 0.00001NC_013960.1-152360  Nitrosococcus_wardiae   47  1.00000 0.11041NZ_CP186025.1-22373 Vibrio_anguillarum  18  1.00000 0.00872

Similar to phylogenetic placement, you can use the --summarize option to aggregate placement across all reads and report weighted count values and normalized sequence abundances. Please note that sequence abundances are not equivalent to taxonomic profiles as the normalization is done across all ranks not per rank (i.e., species level profile).

krepp place -i data/toy-index -q data/query_mixture.fq.gz \    -l data/reference_taxonomy_lineages.tsv -o results/taxplacements_summarized.tsvhead results/taxplacements_summarized.tsvgrep "^Nitrosococcus" results/taxplacements_summarized.tsv

Nitrosococcus_watsonii  49      301.26923       0.00784Nitrosococcus_oceani    45      5874.38590      0.15279Nitrosococcus_wardiae   47      8900.17328      0.23149Nitrosococcus   51      531.75661       0.01383

Conclusions

We covered the core krepp workflow: indexing, distance estimation, phylogenetic placement, and taxonomic placement using a small toy reference set.

Distance estimation (krepp dist) computes per-read Hamming distances to reference genomes, akin to the ratio of mismatches one would obtain through alignment, but sensitive to more divergent sequences. The default command produces a tab-separated table of read-to-reference mappings and maximum likelihood distances. Filtering (--filter) retains only statistically close hits; the --summarize flag aggregates results into operational genomic unit counts, which can be used for downstream analysis and sample comparison.

Phylogenetic placement (krepp place -t) finds placements of query reads on a given reference phylogeny, producing a .jplace file by default, a format that can be further processed by tools such as gappa, iTOL, and QIIME 2. Taxonomic placement (krepp place -l) uses a lineage file to assign reads to named clades. Both support tabular (--tabular) and summarised (--summarize) outputs, similar to distance estimation.

Exercises with Web of Life

For further exercises, you can use the same type of commands with a slightly larger index we downloaded earlier. This is the tiny (i.e., heavily minimized and downsampled) version of the Web of Life index (>10,000 microbial genomes, see this page for the full versions) on the same query mixture:

Figure 6. Per-query mapping rate and mean distance to the best-matching reference, using the WoL index. With denser sampling and a more diverse representation, mapping rates are uniformly high and best-reference distances are consistently low, meaning that all these queries have relatively close matches in this index compared to the toy index we built.

Figure 7. Placement heat-tree on the WoL reference phylogeny (>10,000 leaves). Since the toy sample we generated has low complexity, only a few clades/branches are highlighted. Real and complex samples could result in more widely spread placements.