A rust FFI library for minimap2. In development! Feedback appreciated!

Structure

minimap2-sys is the raw FFI bindings to minimap2. minimap2 is the more opinionated, rusty version.

How to use

Requirements

minimap2 = "0.1.22+minimap2.2.28"

Also see Features

Tested with rustc 1.82.0 and nightly. So probably a good idea to upgrade before running. But let me know if you run into pain points with older versions and will try to fix.

Minimap2 Version Table

Usage

Create an Aligner

let mut aligner = Aligner::builder()
    .map_ont()
    .with_threads(8)
    .with_cigar()
    .with_index("ReferenceFile.fasta", None)
    .expect("Unable to build index");

Align a sequence:

let seq: Vec<u8> = b"ACTGACTCACATCGACTACGACTACTAGACACTAGACTATCGACTACTGACATCGA";
let alignment = aligner
    .map(&seq, false, false, None, None, Some(b"My Sequence Name"))
    .expect("Unable to align");

Presets

All minimap2 presets should be available (see functions section):

let aligner = map_ont();
let aligner = asm20();

Note Each preset overwrites different arguments. Using multiple at a time is not technically supported, but will work. Results unknown. So be careful! It's equivalent to running minimap2 -x map_ont -x short ...

Customization

MapOpts and IdxOpts can be customized with Rust's struct pattern, as well as applying mapping settings. Inspired by bevy.

let mut aligner: Aligner<PresetSet> = Aligner::builder().map_ont();
aligner.mapopt.seed = 42;
aligner.mapopt.best_n = 1;
aligner.idxopt.k = 21;
self.mapopt.flag |= MM_F_COPY_COMMENT as i64; // Setting a flag. If you do this frequently, open an [issue](https://github.com/jguhlin/minimap2-rs/issues/new) asking for an ergonomic function!
self.idxopt.flag |= MM_I_HPC as i32;

See full list of options below.

Working Example

Examples Directory

There are two working examples directly in this repo. In both instances below, 64 is the number of threads to allocate.

Channel-based multi-threading

cargo run --example channels -- reference_genome.fasta reads.fasta 64

Rayon-based multi-threading

cargo run --example rayon -- reference_genome.fasta reads.fasta 64

Depending on your needs you can probably do just fine with Rayon. But for very large implementations, interactivity, or limited memory, using channels may be the way to go.

Fakeminimap2

There is a binary called "fakeminimap2" which demonstrates basic usage and multithreading using channels or rayon. You can find it in this repo for an example. It it much more fully featured example, with an output interface, some mouse support, and interaction.

Code Examples

Alignment functions return a Mapping struct. The Alignment struct is only returned when the Aligner is created using .with_cigar().

A very simple example would be:

let mut file = std::fs::File::open(query_file);
let mut reader = BufReader::new(reader);
let mut fasta = Fasta::from_buffer(&mut reader)

for seq in reader {
    let seq = seq.unwrap();
    let alignment: Vec<Mapping> = aligner
        .map(&seq.sequence.unwrap(), false, false, None, None, None)
        .expect("Unable to align");
    println!("{:?}", alignment);
}

There is a map_file function that works on an entire file, but it is not-lazy and thus not suitable for large files. It may be removed in the future or moved to a separate lib.

let mappings: Result<Vec<Mapping>> = aligner.map_file("query.fa", false, false);

Multithreading

Multithreading is supported, for implementation example see fakeminimap2. Minimap2 also supports threading itself, and will use a minimum of 3 cores for building the index. Multithreading for mapping is left to the end-user.

Adjust the number of threads used to build the index:

let mut aligner = Aligner::builder()
    .map_ont()
    .with_index_threads(8);

Experimental Rayon support

This appears to work. See fakeminimap2 for full implementation.

use rayon::prelude::*;

let results = sequences.par_iter().map(|seq| {
    aligner.map(seq.as_bytes(), false, false, None, None, None).unwrap()
}).collect::<Vec<_>>();

Arc cloning the Aligner

Also works. Otherwise directly cloning the aligner will Arc clone the internal index.

Features

The following crate features are available:

• map-file - Enables the ability to map a file directly to a reference. Enabled by deafult
• htslib - Provides an interface to minimap2 that returns rust_htslib::Records
• simde - Enables SIMD Everywhere library in minimap2
• zlib-ng - Enables the use of zlib-ng for faster compression
• curl - Enables curl for htslib
• static - Builds minimap2 as a static library
• sse2only - Builds minimap2 with only SSE2 support

Map-file is a default feature and enabled unless otherwise specified.

Missing Features

Create an issue if you need any of the following:

• setting mismatch penalty for base transitions minimap 2.27 release notes
• Generate ds tags to indicate uncertainty in indels

Potentially others. Please create an issue!

Building for MUSL

Follow these instructions.

In brief, using bash shell:

docker pull messense/rust-musl-cross:x86_64-musl
alias rust-musl-builder='docker run --rm -it -v "$(pwd)":/home/rust/src messense/rust-musl-cross:x86_64-musl'
rust-musl-builder cargo build --release

Minimap2 is tested on x86_64 and aarch64 (arm64). Other platforms may work, please open an issue if minimap2 compiles but minimap2-rs does not.

Features tested with MUSL

• htslib - Success
• simde - Success

Tools using this binding

• Chopper - Long read trimming and filtering
• mappy-rs - Drop-in multi-threaded replacement for python's mappy
• HiFiHLA - HLA star-calling tool for PacBio HiFi data
• STRdust - Tandem repeat genotyper for long reads
• oarfish - transcript quantification from long-read RNA-seq data
• lrge - Long Read-based Genome size Estimation from overlaps

Next things todo

• Iterator interface for map_file
• -sys Possible to decouple from pthread?

Citation

Please cite the appropriate minimap2 papers if you use this in your work, as well as this library.

DOI for this library

... coming soon ...

Minimap2 Papers

Li, H. (2018). Minimap2: pairwise alignment for nucleotide sequences. Bioinformatics, 34:3094-3100. [doi:10.1093/bioinformatics/bty191][doi]

and/or:

Li, H. (2021). New strategies to improve minimap2 alignment accuracy. Bioinformatics, 37:4572-4574. [doi:10.1093/bioinformatics/btab705][doi2]

Minimap2 Mapping and Indexing Options

See customization for how to use these.

Mapping Options (MapOpt in rust, alias for mm_mapopt_t)

Mapping Flags (MM_F_*)

Index Options (IdxOpt in rust, alias for mm_idxopt_t)

Indexing Flags (MM_I_*)

Changelog

0.1.22 minimap2 2.28

Changes

• Fixed a memory segfault when re-using a thread local buffer. Not sure why it occurs, but this fix seems to solve it.

0.1.21 minimap2 2.28

Contributors to this release: @mbhall88 @rob-p @Sam-Sims @charlesgregory @PB-DB

Breaking Changes

• Map now returns Arc String's to reduce memory allocation for large and/or repetitive jobs
• map now takes an additional argument, query_name: Option<&[u8]>, possibly solves #75 (@rob-p @mbhall88 @jguhlin)
• Arc the Index, to prevent double-frees, solves #71
• Map file now passes in query name, which should help with #75
• Supplementary flag now better detected (@rob-p)
• FIX: Cigar string missing softclip operation (@Sam-Sims)

Migration Guide

• Make all setting changes before calling a with_index, with_seq's function
• Change all map calls to include a query name, or None if not needed

Other Changes

• Add ergonomic functions n_seq and get_seq.
• Better docs on applying presets, solves #84
• Better detection of target arch c_char's and ptr's, solves #82
• Support for M1 Mac compilation and addition of github workflows to test it, solving #81
• Rayon test, so some support, closes #5
• Static str's and now static CStr's
• FIX: memory leak due to sequences allocated by minimap2 not being freed @charlesgregory
• Add Send + Sync to Aligner, along with unit test @PB-DB
• Experimental Android support (tested on aarch64 and x86_64), solves #66
• Added flag and option documents
• Added with_gap_open penalty ergonomic function

0.1.20 minimap2 2.28

• Fix htslib errors. No update to -sys crate needed.

0.1.19 minimap2 2.28

• Fix memory leak by @charlesgregory

0.1.18 minimap2 2.28

• Update to minimap2 v2.28 @jguhlin
• Support for lrhqae preset @jguhlin

0.1.17 minimap2 2.27

• Mark bam::Record objects as supplementary. #52 @PB-DB
• Only use rust-htslib/curl when curl feature is enabled. #53 @PB-DB
• Update to minimap2 v2.27 @jguhlin
• Switch to needletail for reading fast files (features map-file) @jguhlin
• Convert functions to take slices of vectors instead of refs to vecs &[Vec<u8>] instead of &Vec<Vec<u8>> @jguhlin
• breaking Curl is no longer a default option for htslib, please re-enable it as needed with cargo.toml features
• breaking Now using needletail for map-files, enabled by default. However, compression algorithms are disabled. Please enable with cargo.toml features
• Experimental rayon support
• aligner.with_cigar_clipping() to add soft clipping to the CIGAR vec (with_cigar() still adds to only the string, following the minimap2 outputs for PAF)
• breaking .with_threads() is now .with_index_threads() to make it more clear

0.1.16 minimap2 2.26

• Much better cross compilation support thanks to @Adoni5

0.1.15 minimap2 2.26

• Compilation on aarch64 thanks to @leiste375
• README corrections thanks to @wdecoster
• Better support for static builds / linking
• Update fffx to a version that uses bytelines without tokio. Drastically reduces compile times and dependency tree.

0.1.14 minimap2 2.26

• Memory leak fixed by @Adoni5
• Updated deps

0.1.13 minimap2 2.26

• Add with_seq to support indexing a single sequence (as per mappy: https://github.com/lh3/minimap2/blob/master/python/mappy.pyx#L115)
• minimap2-rs: update rust-htslib deps
• simdutf8 now optional dependency requiring map-file feature to be enabled
• Support soft-clipping string in CIGAR. WARNING: Does not support hard clipping. Please open an issue if you need this.
• Update minimap to 2.26
• Not convinced SSE41/SSE2 are working properly. Recommend simde.

0.1.11

• HTS lib: add support for optional quality scores by @eharr

0.1.10

• HTS lib support by @eharr
• HTS lib: Output sam/bam files by @eharr
• More tests by @eharr
• Display impl for Strand thanks to @ahcm
• Update minimap2-sys to latest version by @jguhlin
• -sys crate mm2fast added as additional backend by @jguhlin
• zlib dep changes by @jguhlin (hopefully now it is more portable and robust)
• -sys crate now supports SIMDe

0.1.9

• Thanks for @Adoni5 for switching to builder pattern, and @eharr for adding additional fields to alignment.
• Do not require libclang for normal compilation.

0.1.8

• Multithreading support (use less raw pointers, and treat more like rust Struct's)

0.1.7

• use libc instead of std:ffi::c_int as well

0.1.6

• Support slightly older versions of rustc by using libc:: rather than std::ffi for c_char (Thanks dwpeng!)
• Use fffx module for fasta/q parsing

Funding