FASTA and FASTQ parsing and writing in Rust. Build status

Note: the master branch contains the development for version 0.4.0. The currently stable version is on a separate branch.

This library provides readers for the the following sequence formats:

  • FASTQ (including multi-line FASTQ)
  • "FASTX": Automatic recognition of the sequence format (either FASTA or FASTQ)

Documentation for development version (0.4.0-alpha.x)

Documentation for the stable version (0.3.x)


  • Fast readers that minimize the use of allocations and copying of memory
  • Flexible methods for writing FASTA and FASTQ
  • Informative errors with exact positional information
  • Support for recording the position and seeking back
  • Serde support (for owned data structures)
  • Functions for parallel processing
  • Thoroughly tested using fuzzing techniques see here

Simple example

Reads FASTA sequences from STDIN and writes them to STDOUT if their length is > 100. Otherwise it prints a message.

use seq_io::fasta::{Reader,Record};
use std::io;

let mut reader = Reader::new(io::stdin());
let mut stdout = io::stdout();

while let Some(result) = {
    let record = result.expect("reading error");
    // determine sequence length
    let seqlen = record.seq_lines()
                       .fold(0, |l, seq| l + seq.len());
    if seqlen > 100 {
        record.write_wrap(&mut stdout, 80).expect("writing error");
    } else {
        eprintln!("{} is only {} long","not UTF-8"), seqlen);

Records are directly borrowing data from the internal buffered reader, no further allocation or copying takes place. As a consequence, the while let construct has to be used instead of a for loop.

seq_lines() directly iterates over the sequence lines, whose position is remembered by the record, again without further copying.

Note: Make sure to add lto = true to the release profile in Cargo.toml because calls to functions of the underlying buffered reader (buf_redux) are not inlined otherwise.

Similar projects in Rust

  • Rust-Bio: Binformatics library that provides simple and easy to use FASTA and FASTQ readers.
  • fastq-rs: Very fast FASTQ parser. seq_io was inspired by fastq_rs in many ways.
  • Needletail: FASTA, FASTQ, FASTX
  • fasten implements its own FASTQ reader

Performance comparisons

The following bar chart shows the results of a few benchmarks on random sequences generated in memory (FASTA sequences either on a single line or wrapped to a width of 80).

The readers from this crate are also compared with fastq-rs and Rust-Bio parsers. The latter is only present in the "owned" section, since there is no possibility to iterate without allocating records.

More benchmarks can be found on a separate page.

benchmark results


FASTA and FASTQ parsing in Rust

Seq_io Info

⭐ Stars 29
🔗 Source Code
🕒 Last Update 7 months ago
🕒 Created 5 years ago
🐞 Open Issues 2
➗ Star-Issue Ratio 15
😎 Author markschl