Prodigal (Rust)

Pure Rust rewrite of Prodigal v2.6.3 — a prokaryotic gene prediction tool.

This is a translation of the original code and not the authorative implementation. This code should generate bitwise equal output to the original. Please report any deviations

The aim of this project is to increase performance, especially by providing this code through a type-safe library interface. The code can also be compiled to be used for webassembly.

Installation

cargo install prodigal-rs

Or build from source:

cargo build --release

No C compiler, zlib, or other system libraries required.

Library usage

[dependencies]
prodigal-rs = "0.2"

Metagenomic mode (simplest)

Predict genes using pre-trained models — no training step needed:

use prodigal_rs::predict_meta;

fn main() -> Result<(), prodigal_rs::ProdigalError> {
    let sequence = b"ATGCGATCGATCGATCG...";
    let genes = predict_meta(sequence)?;

    for gene in &genes {
        println!(
            "{}-{} ({}) score={:.1} conf={:.1}%",
            gene.begin, gene.end, gene.strand, gene.score, gene.confidence
        );
    }
    Ok(())
}

Single genome mode

Train on the genome first, then predict on individual contigs:

use prodigal_rs::{train, predict};

fn main() -> Result<(), prodigal_rs::ProdigalError> {
    // Train on the full genome (>= 20,000 bp required)
    let genome = std::fs::read("genome.fasta")?;
    let training = train(&genome)?;

    // Predict genes on each contig using the trained model
    let contig = b"ATGCGATCGATCG...";
    let genes = predict(contig, &training)?;

    for gene in &genes {
        println!(
            "{}-{} {} {} gc={:.3}",
            gene.begin, gene.end, gene.strand, gene.start_codon, gene.gc_content
        );
    }

    // Save/load training for later reuse
    training.save("genome.trn")?;
    let training = prodigal_rs::TrainingData::load("genome.trn")?;

    Ok(())
}

Batch processing (parallel)

For processing many sequences, MetaPredictor caches the 50 models and evaluates them in parallel:

use prodigal_rs::MetaPredictor;

fn main() -> Result<(), prodigal_rs::ProdigalError> {
    let predictor = MetaPredictor::new()?;

    for record in my_fasta_records {
        let genes = predictor.predict(&record.sequence)?;
        println!("{}: {} genes", record.name, genes.len());
    }
    Ok(())
}

Custom configuration

use prodigal_rs::{predict_meta_with, ProdigalConfig};

fn main() -> Result<(), prodigal_rs::ProdigalError> {
    let config = ProdigalConfig {
        translation_table: 4,    // Mycoplasma genetic code
        closed_ends: true,       // No genes running off edges
        ..Default::default()
    };

    let genes = predict_meta_with(b"ATGCGATCG...", &config)?;
    Ok(())
}

Gene prediction results

Each PredictedGene contains:

CLI usage

prodigal-rs accepts the same flags as the original prodigal:

# Single genome, GenBank output
prodigal-rs -i genome.fasta -o genes.gbk

# Metagenomic mode, GFF output with protein translations
prodigal-rs -i contigs.fasta -p meta -f gff -o genes.gff -a proteins.faa

# All outputs at once
prodigal-rs -i genome.fasta -o genes.gff -f gff -a proteins.faa -d genes.fna -s starts.txt

# Generate and reuse a training file
prodigal-rs -i genome.fasta -t genome.trn
prodigal-rs -i genome.fasta -t genome.trn -o genes.gbk

Supports gzip-compressed input files transparently.

Testing

# Build the C binary first (needed only for comparison tests)
cd Prodigal && make && cd ..

cargo test

28 tests cover: the high-level API (metagenomic prediction, single-genome training + prediction, training save/load, error handling, custom config), byte-identical CLI output vs the original C binary across all output formats and flag combinations, and struct layout verification.

Performance

~2x faster than the original C implementation (gcc -O3) on typical workloads.

License

GPL-3.0 (same as the original Prodigal).

Credits

Original Prodigal by Doug Hyatt, University of Tennessee / Oak Ridge National Lab. Based on Prodigal commit c1e2d36 (v2.6.3).