henhaobio
Sign in

BioinformaticsBioinformaticsPeer-reviewed journal article

Gfastats: conversion, evaluation and manipulation of genome sequences using assembly graphs

Giulio FormentiiD, Linelle Ann L. AbuegiD, Angelo Brajuka, Nadolina BrajukaiD, Cristóbal Gallardo AlbaiD, Alice Maria GianiiD, Olivier D. FedrigoiD, Erich David JarvisiD

PDFDOIPreprintCode
In-depth full-text digest available · Jump to digest ↓

Abstract

MotivationWith the current pace at which reference genomes are being produced, the availability of tools that can reliably and efficiently generate genome assembly summary statistics has become critical. Additionally, with the emergence of new algorithms and data types, tools that can improve the quality of existing assemblies through automated and manual curation are required. ResultsWe sought to address both these needs by developing gfastats, as part of the Vertebrate Genomes Project (VGP) effort to generate high-quality reference genomes at scale. Gfastats is a standalone tool to compute assembly summary statistics and manipulate assembly sequences in fasta, fastq, or gfa [.gz] format. Gfastats stores assembly sequences internally in a gfa-like format. This feature allows gfastats to seamlessly convert fast* to and from gfa [.gz] files. Gfastats can also build an assembly graph that can in turn be used to manipulate the underlying sequences following instructions provided by the user, while simultaneously generating key metrics for the new sequences. Availability and implementationGfastats is implemented in C++. Precompiled releases (Linux, MacOS, Windows) and commented source code for gfastats are available under MIT license at https://github.com/vgl-hub/gfastats. Examples of how to run gfastats are provided in the Github. Gfastats is also available in Bioconda, in Galaxy (https://assembly.usegalaxy.eu) and as a MultiQC module [1] (https://github.com/ewels/MultiQC). An automated test workflow is available to ensure consistency of software updates. Supplementary informationSupplementary data are available at Bioinformatics online.

In-depth summary

Claude Opus 5.5 · xhigh effort · 8 Nov 2026 · from the full text of version 1 (27 Mar 2022) · CC BY 4.0

Gfastats, a C++ tool, computes genome assembly statistics in linear time, converts between FASTA, FASTQ and GFA files, and edits assemblies through a bidirected graph.

As reference genomes multiply, curators need one fast tool that reports assembly statistics across file formats and can edit sequences, because the file formats now used for curation were not designed for it. Existing GFA libraries such as gfatools, the authors say, cannot fully convert between FASTA and GFA or edit assemblies directly; gfastats does both by storing every input as a graph.

Key results

  1. ShownComputing statistics takes time proportional to genome size, and on a single quad-core Intel CPU it takes under a minute for assemblies as large as 4 Gbp.

    Tested on a 2.8 GHz Quad-Core Intel Core i7 with 370 VGP assemblies: all summary statistics took less than a minute for genomes up to 4 Gbp, and runtime grew linearly with size, O(N). Gzip-compressed inputs took slightly longer (Figure 1c). · Results; Figure legends

  2. ClaimedEvery input (FASTA, FASTQ, GFA1/2, gzipped or not) is loaded into the same GFA2-like internal model. One engine therefore converts between formats and reports statistics for the whole assembly or for each contig.

    In v1.2.0, contigs, edges, gaps and paths are C++ classes. Outputs include AGP, BED coordinates and scaffold, contig and gap sizes. Inputs can be filtered by lists or BED files, sorted, and homopolymer-compressed or decompressed. The text reports no test of conversion accuracy. · Abstract; Introduction; Results

  3. ClaimedAssemblies can be edited as a bidirected graph, with segments as nodes and gaps as edges, through a list of Swiss Army Knife (SAK) instructions run in order. Statistics are recalculated after the edits, and the instruction list doubles as a record of the changes.

    The graph is stored as adjacency lists and walked with Depth First Search. Example edits: joining or splitting contigs, reverse-complementing, and removing trailing Ns by deleting terminal gap edges. The authors call the editing overhead minimal but give no number. · Results; Discussion and future perspectives; Figure legends

  4. ClaimedAGP files can be converted into GFA paths, so the output of scaffolding tools such as Bionano Solve and SALSA2 can be added to the assembly graph instead of being flattened into linear sequence.

    This is described as a feature of v1.2.0. The authors contrast it with existing GFA libraries such as gfatools, which they say lack full FASTA/GFA conversion and direct editing. No worked integration example is shown. · Results; Discussion and future perspectives

  5. ClaimedThe authors say gfastats reports scaffold, contig and gap metrics that include several missing from QUAST, SeqKit and Bandage.

    The full list of metrics and the comparison with other tools are only in Supplementary Table 1, which is not included in the text. The metrics include area-under-the-curve (AuN) statistics. · Results; section 6

Methods, data and reproducibility

An object-oriented C++ implementation (v1.2.0) stores segments, gaps, edges and paths as classes in a GFA2-like model. It calculates statistics as it reads the input, and can build a bidirected adjacency-list graph, traversed by depth-first search and edited with sequential Swiss Army Knife instructions.

  • Genome assemblies from the Vertebrate Genomes Project (VGP), used to test runtime against genome size · multiple vertebrate species (VGP) · n = 370 genome assemblies
Methods & tools
gfastats v1.2.0, Swiss Army Knife (SAK) internal instruction engine, Depth First Search graph traversal, Bionano Solve, SALSA2, gfatools, QUAST, SeqKit, Bandage, MultiQC, Galaxy (assembly.usegalaxy.eu), Bioconda
Software & environment
Written in C++ (v1.2.0 described). Precompiled releases for Linux, MacOS and Windows; MIT license. Also distributed through Bioconda, Galaxy and a MultiQC module, with an automated test workflow to keep software updates consistent.
Assay conditions & compute
Benchmarked on a 2.8 GHz Quad-Core Intel Core i7: all statistics in under a minute for assemblies up to 4 Gbp, with linear O(N) runtime and a small extra cost for gzip-compressed input. Memory use is not reported.
Reproducibility gaps
The text does not identify the 370 VGP benchmark assemblies or give runtimes for each one. The comparison of metrics with other tools appears only in Supplementary Table 1.
Limitations (3)
  • The authors list features still missing from v1.2.0 as future work: file indexing to test several hypotheses with little extra runtime, pattern search, soft and hard masking, and more SAK instructions. · stated by the authors
  • Speed was measured on only one CPU, with no head-to-head runtime or correctness comparison against QUAST, SeqKit or gfatools in the text. The claim that editing adds minimal overhead is not quantified, and memory use is not reported. · noted in this summary
  • The text reports no direct check that format conversion is accurate (for example round-trip FASTA to GFA to FASTA) or that SAK edits are correct on real curation cases. Only an automated test workflow is mentioned. · noted in this summary

Read this if you need one fast command-line tool to compute assembly statistics, convert between FASTA, FASTQ and GFA, or record curation edits on scaffold graphs as reproducible scripts.

Citations
1,290
FWCI
61.70
Field percentile
top 1%

Reproducibility ledger

Nobody has reported trying to reproduce this paper yet. Did you replicate an experiment or run the code? Your report saves the next lab a week.

Sign in to file a reproducibility report.

Related papers

Similarity Map
SelectedSame fieldCross-field
THISMallawaarac '26Pani '26Manchanda '20Rozov '17Chow '16Larivière '24
61% semantic matchBioinformatics
Vijini Mallawaarachchi, George Spyro Bouras, Ryan R. Wick+3 more·Bioinformatics Advances·Jan 1, 2026· 1 citations