Debian Med Next Generation Sequencing packages

Anfo is a mapper in the spirit of Soap/Maq/Bowtie, but its implementation takes more after BLAST/BLAT. It's most useful for the alignment of sequencing reads where the DNA sequence is somehow modified (think ancient DNA or bisulphite treatment) and/or there is more divergence between sample and reference than what fast mappers will handle gracefully (say the reference genome is missing and a related species is used instead).

ARDEN (Artificial Reference Driven Estimation of false positives in NGS data) is a novel benchmark that estimates error rates based on real experimental reads and an additionally generated artificial reference genome. It allows the computation of error rates specifically for a dataset and the construction of a ROC-curve. Thereby, it can be used to optimize parameters for read mappers, to select read mappers for a specific problem or also to filter alignments based on quality estimation.

ART is a set of simulation tools to generate synthetic next-generation sequencing reads. ART simulates sequencing reads by mimicking real sequencing process with empirical error models or quality profiles summarized from large recalibrated sequencing data. ART can also simulate reads using user own read error model or quality profiles. ART supports simulation of single-end, paired-end/mate-pair reads of three major commercial next-generation sequencing platforms: Illumina's Solexa, Roche's 454 and Applied Biosystems' SOLiD. ART can be used to test or benchmark a variety of method or tools for next-generation sequencing data analysis, including read alignment, de novo assembly, SNP and structure variation discovery. ART was used as a primary tool for the simulation study of the 1000 Genomes Project . ART is implemented in C++ with optimized algorithms and is highly efficient in read simulation. ART outputs reads in the FASTQ format, and alignments in the ALN format. ART can also generate alignments in the SAM alignment or UCSC BED file format. ART can be used together with genome variants simulators (e.g. VarSim) for evaluating variant calling tools or methods.

ArtificialFastqGenerator takes the reference genome (in FASTA format) as input and outputs artificial FASTQ files in the Sanger format. It can accept Phred base quality scores from existing FASTQ files, and use them to simulate sequencing errors. Since the artificial FASTQs are derived from the reference genome, the reference genome provides a gold-standard for calling variants (Single Nucleotide Polymorphisms (SNPs) and insertions and deletions (indels)). This enables evaluation of a Next Generation Sequencing (NGS) analysis pipeline which aligns reads to the reference genome and then calls the variants.

BamTools facilitates research analysis and data management using BAM files. It copes with the enormous amount of data produced by current sequencing technologies that is typically stored in compressed, binary formats that are not easily handled by the text-based parsers commonly used in bioinformatics research.

BamTools provides both a C++ API for BAM file support as well as a command-line toolkit.

This is the bamtools command-line toolkit.

Available bamtools commands:

 convert  Converts between BAM and a number of other formats
 count    Prints number of alignments in BAM file(s)
 coverage Prints coverage statistics from the input BAM file
 filter   Filters BAM file(s) by user-specified criteria
 header   Prints BAM header information
 index    Generates index for BAM file
 merge    Merge multiple BAM files into single file
 random   Select random alignments from existing BAM file(s), intended more
          as a testing tool.
 resolve  Resolves paired-end reads (marking the IsProperPair flag as needed)
 revert   Removes duplicate marks and restores original base qualities
 sort     Sorts the BAM file according to some criteria
 split    Splits a BAM file on user-specified property, creating a new BAM
          output file for each value found
 stats    Prints some basic statistics from input BAM file(s)

BCFtools is a set of utilities that manipulate variant calls in the Variant Call Format (VCF) and its binary counterpart BCF. All commands work transparently with both VCFs and BCFs, both uncompressed and BGZF-compressed.

The BEDTools utilities allow one to address common genomics tasks such as finding feature overlaps and computing coverage. The utilities are largely based on four widely-used file formats: BED, GFF/GTF, VCF, and SAM/BAM. Using BEDTools, one can develop sophisticated pipelines that answer complicated research questions by streaming several BEDTools together.

The groupBy utility is distributed in the filo package.

eXpress is a streaming tool for quantifying the abundances of a set of target sequences from sampled subsequences. Example applications include transcript-level RNA-Seq quantification, allele-specific/haplotype expression analysis (from RNA-Seq), transcription factor binding quantification in ChIP-Seq, and analysis of metagenomic data. It is based on an online-EM algorithm that results in space (memory) requirements proportional to the total size of the target sequences and time requirements that are proportional to the number of sampled fragments. Thus, in applications such as RNA-Seq, eXpress can accurately quantify much larger samples than other currently available tools greatly reducing computing infrastructure requirements. eXpress can be used to build lightweight high-throughput sequencing processing pipelines when coupled with a streaming aligner (such as Bowtie), as output can be piped directly into eXpress, effectively eliminating the need to store read alignments in memory or on disk.

In an analysis of the performance of eXpress for RNA-Seq data, it was observed that this efficiency does not come at a cost of accuracy. eXpress is more accurate than other available tools, even when limited to smaller datasets that do not require such efficiency. Moreover, like the Cufflinks program, eXpress can be used to estimate transcript abundances in multi-isoform genes. eXpress is also able to resolve multi-mappings of reads across gene families, and does not require a reference genome so that it can be used in conjunction with de novo assemblers such as Trinity, Oases, or Trans-ABySS. The underlying model is based on previously described probabilistic models developed for RNA-Seq but is applicable to other settings where target sequences are sampled, and includes parameters for fragment length distributions, errors in reads, and sequence-specific fragment bias.

eXpress can be used to resolve ambiguous mappings in other high-throughput sequencing based applications. The only required inputs to eXpress are a set of target sequences and a set of sequenced fragments multiply-aligned to them. While these target sequences will often be gene isoforms, they need not be. Haplotypes can be used as the reference for allele-specific expression analysis, binding regions for ChIP-Seq, or target genomes in metagenomics experiments. eXpress is useful in any analysis where reads multi-map to sequences that differ in abundance.

Efficient tool for clustering and assembling short reads, especially for RAD.

Rainbow is developed to provide an ultra-fast and memory-efficient solution to clustering and assembling short reads produced by RAD-seq. First, Rainbow clusters reads using a spaced seed method. Then, Rainbow implements a heterozygote calling like strategy to divide potential groups into haplotypes in a top-down manner. long a guided tree, it iteratively merges sibling leaves in a bottom-up manner if they are similar enough. Here, the similarity is defined by comparing the 2nd reads of a RAD segment. This approach tries to collapse heterozygote while discriminate repetitive sequences. At last, Rainbow uses a greedy algorithm to locally assemble merged reads into contigs. Rainbow not only outputs the optimal but also suboptimal assembly results. Based on simulation and a real guppy RAD-seq data, it is shown that Rainbow is more competent than the other tools in dealing with RAD-seq data.

Basic local alignment with successive refinement (BLASR) is a method for mapping single-molecule sequencing reads against a reference genome. Such reads are thousands of bases long, with divergence between them and the genome being dominated by insertion and deletion error.

This package addresses the problem to interpret the results from the latest (2010) DNA sequencing technologies. Those will yield fairly short stretches and those cannot be interpreted directly. It is the challenge for tools like Bowtie to give a chromosomal location to the short stretches of DNA sequenced per run.

Bowtie aligns short DNA sequences (reads) to the human genome at a rate of over 25 million 35-bp reads per hour. Bowtie indexes the genome with a Burrows-Wheeler index to keep its memory footprint small: typically about 2.2 GB for the human genome (2.9 GB for paired-end).

is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. It is particularly good at aligning reads of about 50 up to 100s or 1,000s of characters, and particularly good at aligning to relatively long (e.g. mammalian) genomes.

Bowtie 2 indexes the genome with an FM Index to keep its memory footprint small: for the human genome, its memory footprint is typically around 3.2 GB. Bowtie 2 supports gapped, local, and paired-end alignment modes

BWA is a software package for mapping low-divergent sequences against a large reference genome, such as the human genome. It consists of three algorithms: BWA-backtrack, BWA-SW and BWA-MEM. The first algorithm is designed for Illumina sequence reads up to 100bp, while the rest two for longer sequences ranged from 70bp to 1Mbp. BWA-MEM and BWA-SW share similar features such as long-read support and split alignment, but BWA-MEM, which is the latest, is generally recommended for high-quality queries as it is faster and more accurate. BWA-MEM also has better performance than BWA-backtrack for 70-100bp Illumina reads.

Canu is a fork of the Celera Assembler, designed for high-noise single-molecule sequencing (such as the PacBio RS II or Oxford Nanopore MinION).

Canu is a hierarchical assembly pipeline which runs in four steps:

• Detect overlaps in high-noise sequences using MHAP
• Generate corrected sequence consensus
• Trim corrected sequences
• Assemble trimmed corrected sequences

Change-O is a collection of tools for processing the output of V(D)J alignment tools, assigning clonal clusters to immunoglobulin (Ig) sequences, and reconstructing germline sequences.

Dramatic improvements in high-throughput sequencing technologies now enable large-scale characterization of Ig repertoires, defined as the collection of trans-membrane antigen-receptor proteins located on the surface of B cells and T cells. Change-O is a suite of utilities to facilitate advanced analysis of Ig and TCR sequences following germline segment assignment. Change-O handles output from IMGT/HighV-QUEST and IgBLAST, and provides a wide variety of clustering methods for assigning clonal groups to Ig sequences. Record sorting, grouping, and various database manipulation operations are also included.

This package installs the library for Python 3.

CRAC is a tool to analyze High Throughput Sequencing (HTS) data in comparison to a reference genome. It is intended for transcriptomic and genomic sequencing reads. More precisely, with transcriptomic reads as input, it predicts point mutations, indels, splice junction, and chimeric RNAs (ie, non colinear splice junctions). CRAC can also output positions and nature of sequence error that it detects in the reads. CRAC uses a genome index. This index must be computed before running the read analysis. For this sake, use the command "crac-index" on your genome files. You can then process the reads using the command crac. See the man page of CRAC (help file) by typing "man crac". CRAC requires large amount of main memory on your computer. For processing against the Human genome, say 50 million reads of 100 nucleotide each, CRAC requires about 40 gigabytes of main memory. Check whether the system of your computing server is equipped with sufficient amount of memory before launching an analysis.

Cutadapt helps with biological sequence clean tasks by finding the adapter or primer sequences in an error-tolerant way. It can also modify and filter reads in various ways. Adapter sequences can contain IUPAC wildcard characters. Also, paired-end reads and even colorspace data is supported. If you want, you can also just demultiplex your input data, without removing adapter sequences at all.

This package contains the user interface.

Tieto nástroje umožňujú nájsť všetky významné lokálne zarovnania medzi čítaniami zakódovanými v databáze Dazzler. Predpokladom je, že čítania sú zo sekvencéra dlhých čítaní Pacific Biosciences RS II. To znamená, že čítania sú dlhé a obsahujú veľa šumu, v priemere 15 %.

DeepNano is alternative basecaller for Oxford Nanopore MinION reads based on deep recurrent neural networks.

Currently it works with SQK-MAP-006 and SQK-MAP-005 chemistry and as a postprocessor for Metrichor.

Software discoSnp is designed for discovering Single Nucleotide Polymorphism (SNP) from raw set(s) of reads obtained with Next Generation Sequencers (NGS).

Note that number of input read sets is not constrained, it can be one, two, or more. Note also that no other data as reference genome or annotations are needed.

The software is composed by two modules. First module, kissnp2, detects SNPs from read sets. A second module, kissreads, enhance the kissnp2 results by computing per read set and for each found SNP:

 1) its mean read coverage
 2) the (phred) quality of reads generating the polymorphism.

This program is superseded by DiscoSnp++.

dnaclust is a tool for clustering large number of short DNA sequences. The clusters are created in such a way that the "radius" of each clusters is no more than the specified threshold.

The input sequences to be clustered should be in Fasta format. The id of each sequence is based on the first word of the seqeunce in the Fasta format. The first word is the prefix of the header up to the first occurrence of white space characters in the header.

DWGSIM simulates short sequencing reads from modern sequencing platforms. DWGSIM generates base error rates using a parametric model, allowing a more realisic error profile. It was originally developed for use in evaluating short read aligners.

Ea-utils provides a set of command-line tools for processing biological sequencing data, barcode demultiplexing, adapter trimming, etc.

Primarily written to support an Illumina based pipeline - but should work with any FASTQs.

Main Tools are:

• fastq-mcf Scans a sequence file for adapters, and, based on a log-scaled threshold, determines a set of clipping parameters and performs clipping. Also does skewing detection and quality filtering.

• fastq-multx Demultiplexes a fastq. Capable of auto-determining barcode id's based on a master set fields. Keeps multiple reads in-sync during demultiplexing. Can verify that the reads are in-sync as well, and fail if they're not.

• fastq-join Similar to audy's stitch program, but in C, more efficient and supports some automatic benchmarking and tuning. It uses the same "squared distance for anchored alignment" as other tools.

• varcall Takes a pileup and calculates variants in a more easily parameterized manner than some other tools.

Fastaq represents a diverse collection of scripts that perform useful and common FASTA/FASTQ manipulation tasks, such as filtering, merging, splitting, sorting, trimming, search/replace, etc. Input and output files can be gzipped (format is automatically detected) and individual Fastaq commands can be piped together.

All-in-one FASTQ preprocessor, fastp provides functions including quality profiling, adapter trimming, read filtering and base correction. It supports both single-end and paired-end short read data and also provides basic support for long-read data.

FastQC aims to provide a simple way to do some quality control checks on raw sequence data coming from high throughput sequencing pipelines. It provides a modular set of analyses which you can use to give a quick impression of whether your data has any problems of which you should be aware before doing any further analysis.

The main functions of FastQC are

• Import of data from BAM, SAM or FastQ files (any variant)
• Providing a quick overview to tell you in which areas there may be problems
• Summary graphs and tables to quickly assess your data
• Export of results to an HTML based permanent report
• Offline operation to allow automated generation of reports without running the interactive application

Flexbar preprocesses high-throughput sequencing data efficiently. It demultiplexes barcoded runs and removes adapter sequences. Moreover, trimming and filtering features are provided. Flexbar increases mapping rates and improves genome and transcriptome assemblies. It supports next-generation sequencing data in fasta/q and csfasta/q format from Illumina, Roche 454, and the SOLiD platform.

Parameter names changed in Flexbar. Please review scripts. The recent months, default settings were optimised, several bugs were fixed and various improvements were made, e.g. revamped command-line interface, new trimming modes as well as lower time and memory requirements.

Fml-asm is a command-line tool for assembling Illumina short reads in regions from 100bp to 10 million bp in size, based on the fermi-lite library. It is largely a light-weight in-memory version of fermikit without generating any intermediate files. It inherits the performance, the relatively small memory footprint and the features of fermikit. In particular, fermi-lite is able to retain heterozygous events and thus can be used to assemble diploid regions for the purpose of variant calling.

Jednojadrová implementácia frekvenčného dolovania podreťazcov, ktorá sa používa na extrakciu podreťazcov rozlišujúcich dve (alebo viaceré) sady dát v sekvenčných dátach s vysokou priepustnosťou.

GIIRA is a gene prediction method that identifies potential coding regions exclusively based on the mapping of reads from an RNA-Seq experiment. It was foremost designed for prokaryotic gene prediction and is able to resolve genes within the expressed region of an operon. However, it is also applicable to eukaryotes and predicts exon intron structures as well as alternative isoforms.

Grinder is a versatile program to create random shotgun and amplicon sequence libraries based on DNA, RNA or proteic reference sequences provided in a FASTA file.

Grinder can produce genomic, metagenomic, transcriptomic, metatranscriptomic, proteomic, metaproteomic shotgun and amplicon datasets from current sequencing technologies such as Sanger, 454, Illumina. These simulated datasets can be used to test the accuracy of bioinformatic tools under specific hypothesis, e.g. with or without sequencing errors, or with low or high community diversity. Grinder may also be used to help decide between alternative sequencing methods for a sequence-based project, e.g. should the library be paired-end or not, how many reads should be sequenced.

HiLive is a read mapping tool that maps Illumina HiSeq (or comparable) reads to a reference genome right in the moment when they are produced. This means, read mapping is finished as soon as the sequencer is finished generating the data.

HINGE is a genome assembler that seeks to achieve optimal repeat resolution by distinguishing repeats that can be resolved given the data from those that cannot. This is accomplished by adding “hinges” to reads for constructing an overlap graph where only unresolvable repeats are merged. As a result, HINGE combines the error resilience of overlap-based assemblers with repeat-resolution capabilities of de Bruijn graph assemblers.

HISAT2 is a fast and sensitive alignment program for mapping next-generation sequencing reads (both DNA and RNA) to a population of human genomes (as well as against a single reference genome). Based on an extension of BWT for graphs a graph FM index (GFM) was designed and implementd. In addition to using one global GFM index that represents a population of human genomes, HISAT2 uses a large set of small GFM indexes that collectively cover the whole genome (each index representing a genomic region of 56 Kbp, with 55,000 indexes needed to cover the human population). These small indexes (called local indexes), combined with several alignment strategies, enable rapid and accurate alignment of sequencing reads. This new indexing scheme is called a Hierarchical Graph FM index (HGFM).

IDBA stands for iterative de Bruijn graph assembler. In computational sequence biology, an assembler solves the puzzle coming from large sequencing machines that feature many gigabytes of short reads from a large genome.

This package provides several flavours of the IDBA assembler, as they all share the same source tree but serve different purposes and evolved over time.

IDBA is the basic iterative de Bruijn graph assembler for second-generation sequencing reads. IDBA-UD, an extension of IDBA, is designed to utilize paired-end reads to assemble low-depth regions and use progressive depth on contigs to reduce errors in high-depth regions. It is a generic purpose assembler and especially good for single-cell and metagenomic sequencing data. IDBA-Hybrid is another update version of IDBA-UD, which can make use of a similar reference genome to improve assembly result. IDBA-Tran is an iterative de Bruijn graph assembler for RNA-Seq data.

IgDiscover analyzes antibody repertoires and discovers new V genes from high-throughput sequencing reads. Heavy chains, kappa and lambda light chains are supported (to discover VH, VK and VL genes).

IGoR (Inference and Generation of Repertoires) is a versatile software to analyze and model immune receptors generation, selection, mutation and all other processes.

The Integrative Genomics Viewer (IGV) is a high-performance viewer that efficiently handles large heterogeneous data sets, while providing a smooth and intuitive user experience at all levels of genome resolution. A key characteristic of IGV is its focus on the integrative nature of genomic studies, with support for both array-based and next-generation sequencing data, and the integration of clinical and phenotypic data. Although IGV is often used to view genomic data from public sources, its primary emphasis is to support researchers who wish to visualize and explore their own data sets or those from colleagues. To that end, IGV supports flexible loading of local and remote data sets, and is optimized to provide high-performance data visualization and exploration on standard desktop systems.

IVA is a de novo assembler designed to assemble virus genomes that have no repeat sequences, using Illumina read pairs sequenced from mixed populations at extremely high depth.

IVA's main algorithm works by iteratively extending contigs using aligned read pairs. Its input can be just read pairs, or additionally you can provide an existing set of contigs to be extended. Alternatively, it can take reads together with a reference sequence.

khmer is a library and suite of command line tools for working with DNA sequence. It is primarily aimed at short-read sequencing data such as that produced by the Illumina platform. khmer takes a k-mer-centric approach to sequence analysis, hence the name.

KisSplice is a piece of software that enables the analysis of RNA-seq data with or without a reference genome. It is an exact local transcriptome assembler that allows one to identify SNPs, indels and alternative splicing events. It can deal with an arbitrary number of biological conditions, and will quantify each variant in each condition. It has been tested on Illumina datasets of up to 1G reads. Its memory consumption is around 5Gb for 100M reads.

Kraken is a system for assigning taxonomic labels to short DNA sequences, usually obtained through metagenomic studies. Previous attempts by other bioinformatics software to accomplish this task have often used sequence alignment or machine learning techniques that were quite slow, leading to the development of less sensitive but much faster abundance estimation programs. Kraken aims to achieve high sensitivity and high speed by utilizing exact alignments of k-mers and a novel classification algorithm.

In its fastest mode of operation, for a simulated metagenome of 100 bp reads, Kraken processed over 4 million reads per minute on a single core, over 900 times faster than Megablast and over 11 times faster than the abundance estimation program MetaPhlAn. Kraken's accuracy is comparable with Megablast, with slightly lower sensitivity and very high precision.

Kraken 2 is the newest version of Kraken, a taxonomic classification system using exact k-mer matches to achieve high accuracy and fast classification speeds. This classifier matches each k-mer within a query sequence to the lowest common ancestor (LCA) of all genomes containing the given k-mer. The k-mer assignments inform the classification algorithm. [see: Kraken 1's Webpage for more details].

Kraken 2 provides significant improvements to Kraken 1, with faster database build times, smaller database sizes, and faster classification speeds. These improvements were achieved by the following updates to the Kraken classification program:

 1. Storage of Minimizers: Instead of storing/querying entire k-mers,
    Kraken 2 stores minimizers (l-mers) of each k-mer. The length of
    each l-mer must be ≤ the k-mer length. Each k-mer is treated by
    Kraken 2 as if its LCA is the same as its minimizer's LCA.
 2. Introduction of Spaced Seeds: Kraken 2 also uses spaced seeds to
    store and query minimizers to improve classification accuracy.
 3. Database Structure: While Kraken 1 saved an indexed and sorted list
    of k-mer/LCA pairs, Kraken 2 uses a compact hash table. This hash
    table is a probabilistic data structure that allows for faster
    queries and lower memory requirements. However, this data structure
    does have a <1% chance of returning the incorrect LCA or returning
    an LCA for a non-inserted minimizer. Users can compensate for this
    possibility by using Kraken's confidence scoring thresholds.
 4. Protein Databases: Kraken 2 allows for databases built from amino
    acid sequences. When queried, Kraken 2 performs a six-frame
    translated search of the query sequences against the database.
 5. 16S Databases: Kraken 2 also provides support for databases not
    based on NCBI's taxonomy. Currently, these include the 16S
    databases: Greengenes, SILVA, and RDP.

LAST is software for comparing and aligning sequences, typically DNA or protein sequences. LAST is similar to BLAST, but it copes better with very large amounts of sequence data. Here are two things LAST is good at:

• Comparing large (e.g. mammalian) genomes.
• Mapping lots of sequence tags onto a genome.

The main technical innovation is that LAST finds initial matches based on their multiplicity, instead of using a fixed size (e.g. BLAST uses 10-mers). This allows one to map tags to genomes without repeat-masking, without becoming overwhelmed by repetitive hits. To find these variable-sized matches, it uses a suffix array (inspired by Vmatch). To achieve high sensitivity, it uses a discontiguous suffix array, analogous to spaced seeds.

The Variant Call Format (VCF) is a flat-file, tab-delimited textual format intended to concisely describe reference-indexed variations between individuals. VCF provides a common interchange format for the description of variation in individuals and populations of samples, and has become the defacto standard reporting format for a wide array of genomic variant detectors.

vcflib provides methods to manipulate and interpret sequence variation as it can be described by VCF. It is both:

• an API for parsing and operating on records of genomic variation as it can be described by the VCF format,
• and a collection of command-line utilities for executing complex manipulations on VCF files.

This package contains several tools using the library.

MACS empirically models the length of the sequenced ChIP fragments, which tends to be shorter than sonication or library construction size estimates, and uses it to improve the spatial resolution of predicted binding sites. MACS also uses a dynamic Poisson distribution to effectively capture local biases in the genome sequence, allowing for more sensitive and robust prediction. MACS compares favorably to existing ChIP-Seq peak-finding algorithms, is publicly available open source, and can be used for ChIP-Seq with or without control samples.

MapDamage is a computational framework written in Python and R, which tracks and quantifies DNA damage patterns among ancient DNA sequencing reads generated by Next-Generation Sequencing platforms.

MapDamage is developed at the Centre for GeoGenetics by the Orlando Group.

Mapsembler2 is a targeted assembly software. It takes as input a set of NGS raw reads (fasta or fastq, gzipped or not) and a set of input sequences (starters).

It first determines if each starter is read-coherent, e.g. whether reads confirm the presence of each starter in the original sequence. Then for each read-coherent starter, Mapsembler2 outputs its sequence neighborhood as a linear sequence or as a graph, depending on the user choice.

Mapsembler2 may be used for (not limited to):

• Validate an assembled sequence (input as starter), e.g. from a de Bruijn graph assembly where read-coherence was not enforced.
• Checks if a gene (input as starter) has an homolog in a set of reads
• Checks if a known enzyme is present in a metagenomic NGS read set.
• Enrich unmappable reads by extending them, possibly making them mappable
• Checks what happens at the extremities of a contig
• Remove contaminants or symbiont reads from a read set

Maq (short for Mapping and Assembly with Quality) builds mapping assemblies from short reads generated by the next-generation sequencing machines. It was particularly designed for Illumina-Solexa 1G Genetic Analyzer, and has a preliminary functionality to handle ABI SOLiD data. Maq is previously known as mapass2.

Developmemt of Maq stopped in 2008. Its successors are BWA and SAMtools.

Maqview is graphical read alignment viewer. It is specifically designed for the Maq alignment file and allows you to see the mismatches, base qualities and mapping qualities. Maqview is nothing fancy as Consed or GAP, but just a simple viewer for you to see what happens in a particular region.

In comparison to tgap-maq, the text-based read alignment viewer written by James Bonfield, Maqview is faster and takes up much less memory and disk space in indexing. This is possibly because tgap aims to be a general-purpose viewer but Maqview fully makes use of the fact that a Maq alignment file has already been sorted. Maqview is also efficient in viewing and provides a command-line tool to quickly retrieve any region in an Maq alignment file.

The MinHash Alignment Process (MHAP--pronounced MAP) is a reference implementation of a probabilistic sequence overlapping algorithm. Designed to efficiently detect all overlaps between noisy long-read sequence data. It efficiently estimates Jaccard similarity by compressing sequences to their representative fingerprints composed on min-mers (minimum k-mer).

The microbiomeutil package comes with the following utilities:

• ChimeraSlayer: ChimeraSlayer for chimera detection.
• NAST-iEr: NAST-based alignment tool.
• WigeoN: A reimplementation of the Pintail 16S anomaly detection utility
• RESOURCES: Reference 16S sequences and NAST-alignments that the tools above leverage.

The mira genome fragment assembler is a specialised assembler for sequencing projects classified as 'hard' due to high number of similar repeats. For expressed sequence tags (ESTs) transcripts, miraEST is specialised on reconstructing pristine mRNA transcripts while detecting and classifying single nucleotide polymorphisms (SNP) occurring in different variations thereof.

The assembler is routinely used for such various tasks as mutation detection in different cell types, similarity analysis of transcripts between organisms, and pristine assembly of sequences from various sources for oligo design in clinical microarray experiments.

The package provides the following executables: Binaries provided:

• mira: for assembly of genome sequences
• miramem: estimating memory needed to assemble projects.
• mirabait: a "grep" like tool to select reads with kmers up to 256 bases.
• miraconvert: is a tool to convert, extract and sometimes recalculate all kinds of data related to sequence assembly files.

Mothur seeks to develop a single piece of open-source, expandable software to fill the bioinformatics needs of the microbial ecology community. It has incorporated the functionality of dotur, sons, treeclimber, s-libshuff, unifrac, and much more. In addition to improving the flexibility of these algorithms, a number of other features including calculators and visualization tools were added.

Nanopolish uses a signal-level hidden Markov model for consensus calling of nanopore genome sequencing data. It can perform signal-level analysis of Oxford Nanopore sequencing data. Nanopolish can calculate an improved consensus sequence for a draft genome assembly, detect base modifications, call SNPs and indels with respect to a reference genome and more.

The PALEOMIX pipelines are a set of pipelines and tools designed to aid the rapid processing of High-Throughput Sequencing (HTS) data: The BAM pipeline processes de-multiplexed reads from one or more samples, through sequence processing and alignment, to generate BAM alignment files useful in downstream analyses; the Phylogenetic pipeline carries out genotyping and phylogenetic inference on BAM alignment files, either produced using the BAM pipeline or generated elsewhere; and the Zonkey pipeline carries out a suite of analyses on low coverage equine alignments, in order to detect the presence of F1-hybrids in archaeological assemblages. In addition, PALEOMIX aids in metagenomic analysis of the extracts.

The pipelines have been designed with ancient DNA (aDNA) in mind, and includes several features especially useful for the analyses of ancient samples, but can all be for the processing of modern samples, in order to ensure consistent data processing.

PBHoney is an implementation of two variant-identification approaches designed to exploit the high mappability of long reads (i.e., greater than 10,000 bp). PBHoney considers both intra-read discordance and soft-clipped tails of long reads to identify structural variants.

PBHoney is part of the PBSuite.

PBJelly is a highly automated pipeline that aligns long sequencing reads (such as PacBio RS reads or long 454 reads in fasta format) to high-confidence draft assembles. PBJelly fills or reduces as many captured gaps as possible to produce upgraded draft genomes.

PBJelly is part of the PBSuite.

The PBSuite contains two projects created for analysis of Pacific Biosciences long-read sequencing data.

• PBJelly - genome upgrading tool
• PBHoney - structural variation discovery

SAM (Sequence Alignment/Map) format is a generic format for storing large nucleotide sequence alignments. Picard Tools includes these utilities to manipulate SAM and BAM files:

 AddCommentsToBam                  FifoBuffer
 AddOrReplaceReadGroups            FilterSamReads
 BaitDesigner                      FilterVcf
 BamIndexStats                     FixMateInformation
                                   GatherBamFiles
 BedToIntervalList                 GatherVcfs
 BuildBamIndex                     GenotypeConcordance
 CalculateHsMetrics                IlluminaBasecallsToFastq
 CalculateReadGroupChecksum        IlluminaBasecallsToSam
 CheckIlluminaDirectory            LiftOverIntervalList
 CheckTerminatorBlock              LiftoverVcf
 CleanSam                          MakeSitesOnlyVcf
 CollectAlignmentSummaryMetrics    MarkDuplicates
 CollectBaseDistributionByCycle    MarkDuplicatesWithMateCigar
 CollectGcBiasMetrics              MarkIlluminaAdapters
 CollectHiSeqXPfFailMetrics        MeanQualityByCycle
 CollectIlluminaBasecallingMetrics MergeBamAlignment
 CollectIlluminaLaneMetrics        MergeSamFiles
 CollectInsertSizeMetrics          MergeVcfs
 CollectJumpingLibraryMetrics      NormalizeFasta
 CollectMultipleMetrics            PositionBasedDownsampleSam
 CollectOxoGMetrics                QualityScoreDistribution
 CollectQualityYieldMetrics        RenameSampleInVcf
 CollectRawWgsMetrics              ReorderSam
 CollectRnaSeqMetrics              ReplaceSamHeader
 CollectRrbsMetrics                RevertOriginalBaseQualitiesAndAddMateCigar
 CollectSequencingArtifactMetrics  RevertSam
 CollectTargetedPcrMetrics         SamFormatConverter
 CollectVariantCallingMetrics      SamToFastq
 CollectWgsMetrics                 ScatterIntervalsByNs
 CompareMetrics                    SortSam
 CompareSAMs                       SortVcf
 ConvertSequencingArtifactToOxoG   SplitSamByLibrary
 CreateSequenceDictionary          SplitVcfs
 DownsampleSam                     UpdateVcfSequenceDictionary
 EstimateLibraryComplexity         ValidateSamFile
 ExtractIlluminaBarcodes           VcfFormatConverter
 ExtractSequences                  VcfToIntervalList
 FastqToSam                        ViewSam

The program pIRS can be used for simulating Illumina PE reads, with a series of characters generated by Illumina sequencing platform, such as insert size distribution, sequencing error(substitution, insertion, deletion), quality score and GC content-coverage bias.

The insert size follows a normal distribution, so users should set the mean value and standard deviation. Usually the standard deviation is set as 1/20 of the mean value. The normal distribution by Box-Muller method is simulated.

The program simulates sequencing error, quality score and GC content- coverage bias according to the empirical distribution profile. Some default profiles counted from lots of real sequencing data are provided.

To simulate reads from diploid genome, users should simulate the diploid genome sequence firstly by setting the ratio of heterozygosis SNP, heterozygosis InDel and structure variation.

For the interpretation of the transcriptome (the abundance and sequence of RNA) of tomour cells one is particularly interested in transcripts that cannot be mapped to single genes but that are seen to be fused as parts from two genes. Likely eplanations are chromosomal translocations.

Pizzly can identify novel such peculiarities, building on interpretations on variable splicing by the tool kallisto. Both tools are elements of the bcbio workflow.

Placnet is a new tool for plasmid analysis in NGS projects. Placnet is optimized to work with Illumina sequences but it also works with 454, Iontorrent or any of the actual sequence technologies.

The input of placnet is a set of contigs and one or more SAM files with the mapping of the reads against the contigs. Placnet obtains a set of files, easily opened on Cytoscape software or other network tools.

poretools is a flexible toolkit for exploring datasets generated by nanopore sequencing devices from MinION for the purposes of quality control and downstream analysis. Poretools operates directly on the native FAST5 (a variant of the HDF5 standard) file format produced by ONT and provides a wealth of format conversion utilities and data exploration and visualization tools.

This package provides a library by the AIRR community to for describing, reporting, storing, and sharing adaptive immune receptor repertoire (AIRR) data, such as sequences of antibodies and T cell receptors (TCRs). Some specific efforts include:

• The MiAIRR standard for describing minimal information about AIRR datasets, including sample collection and data processing information.
• Data representations (file format) specifications for storing large amounts of annotated AIRR data.
• APIs for exposing a common interface to repositories/databases containing AIRR data.
• A community standard for software tools which will allow conforming tools to gain community recognition.

This package installs the library for Python 3.

A Python package for working with and manipulating the GFF and GTF format files typically used for genomic annotations. Files are loaded into a sqlite3 database, allowing much more complex manipulation of hierarchical features (e.g., genes, transcripts, and exons) than is possible with plain-text methods alone.

pRESTO is a toolkit for processing raw reads from high-throughput sequencing of B cell and T cell repertoires.

Dramatic improvements in high-throughput sequencing technologies now enable large-scale characterization of lymphocyte repertoires, defined as the collection of trans-membrane antigen-receptor proteins located on the surface of B cells and T cells. The REpertoire Sequencing TOolkit (pRESTO) is composed of a suite of utilities to handle all stages of sequence processing prior to germline segment assignment. pRESTO is designed to handle either single reads or paired-end reads. It includes features for quality control, primer masking, annotation of reads with sequence embedded barcodes, generation of unique molecular identifier (UMI) consensus sequences, assembly of paired-end reads and identification of duplicate sequences. Numerous options for sequence sorting, sampling and conversion operations are also included.

This package provides the presto Python3 module.

The BEDTools suite of programs is widely used for genomic interval manipulation or “genome algebra”. pybedtools wraps and extends BEDTools and offers feature-level manipulations from within Python.

This is the Python 3 version.

sqt is a collection of command-line tools for working with high-throughput sequencing data. Conceptionally not fixed to use any particular language, many sqt subcommands are currently implemented in Python. For them, a Python package is available with functions for reading and writing FASTA/FASTQ files, computing alignments, quality trimming, etc.

The following tools are offered:

• sqt-coverage -- Compute per-reference statistics such as coverage and GC content
• sqt-fastqmod -- FASTQ modifications: shorten, subset, reverse complement, quality trimming.
• sqt-fastastats -- Compute N50, min/max length, GC content etc. of a FASTA file
• sqt-qualityguess -- Guess quality encoding of one or more FASTA files.
• sqt-globalalign -- Compute a global or semiglobal alignment of two strings.
• sqt-chars -- Count length of the first word given on the command line.
• sqt-sam-cscq -- Add the CS and CQ tags to a SAM file with colorspace reads.
• sqt-fastamutate -- Add substitutions and indels to sequences in a FASTA file.
• sqt-fastaextract -- Efficiently extract one or more regions from an indexed FASTA file.
• sqt-translate -- Replace characters in FASTA files (like the 'tr' command).
• sqt-sam-fixn -- Replace all non-ACGT characters within reads in a SAM file.
• sqt-sam-insertsize -- Mean and standard deviation of paired-end insert sizes.
• sqt-sam-set-op -- Set operations (union, intersection, ...) on SAM/BAM files.
• sqt-bam-eof -- Check for the End-Of-File marker in compressed BAM files.
• sqt-checkfastqpe -- Check whether two FASTQ files contain correctly paired paired-end data.

QIIME 2 is a powerful, extensible, and decentralized microbiome analysis package with a focus on data and analysis transparency. QIIME 2 enables researchers to start an analysis with raw DNA sequence data and finish with publication-quality figures and statistical results. Key features:

• Integrated and automatic tracking of data provenance
• Semantic type system
• Plugin system for extending microbiome analysis functionality
• Support for multiple types of user interfaces (e.g. API, command line, graphical)

QIIME 2 is a complete redesign and rewrite of the QIIME 1 microbiome analysis pipeline. QIIME 2 will address many of the limitations of QIIME 1, while retaining the features that makes QIIME 1 a powerful and widely-used analysis pipeline.

QIIME 2 currently supports an initial end-to-end microbiome analysis pipeline. New functionality will regularly become available through QIIME 2 plugins. You can view a list of plugins that are currently available on the QIIME 2 plugin availability page. The future plugins page lists plugins that are being developed.

QCPipeline is a tool for quality control. The workflow is as follows:

 1. Quality control with FastQC
 2. Trim Reads with Trimmomatic
 3. Quality control of trimmed reads with FastQC
 4. Map reads against reference using bowtie2
 5. Classify reads with Kraken

Microbes are surrounding us, animals, plants and all their parasites with strong effect on these and the environment these live in. Soil quality comes to mind but also the effect that bacteria have on each other. Humans are influencing the absolute and relative abundance of bacteria by antibiotics, food, fertilizers - you name it - and these changes affect us.

QIIME 2 is a powerful, extensible, and decentralized microbiome analysis package with a focus on data and analysis transparency. QIIME 2 enables researchers to start an analysis with raw DNA sequence data and finish with publication-quality figures and statistical results. Key features:

• Integrated and automatic tracking of data provenance
• Semantic type system
• Plugin system for extending microbiome analysis functionality
• Support for multiple types of user interfaces (e.g. API, command line, graphical)

QIIME 2 is a complete redesign and rewrite of the QIIME 1 microbiome analysis pipeline. QIIME 2 will address many of the limitations of QIIME 1, while retaining the features that makes QIIME 1 a powerful and widely-used analysis pipeline.

QIIME 2 currently supports an initial end-to-end microbiome analysis pipeline. New functionality will regularly become available through QIIME 2 plugins. You can view a list of plugins that are currently available on the QIIME 2 plugin availability page. The future plugins page lists plugins that are being developed.