Choosing Your ddRAD Pipeline: Stacks 2 vs ipyrad vs dDocent

Selecting a ddRAD pipeline is not a cosmetic choice—it shapes how many loci you recover, how much missingness you accept, and how credible your downstream inferences look to collaborators and reviewers. In practice, most teams converge on one of three well-documented options:

• Stacks 2 when native paired-end locus assembly and population-genetics exports are priorities.
• ipyrad when you need flexible de novo assembly across diverse taxa and the ability to scale on HPC with MPI.
• dDocent when a usable reference is available and a pragmatic map-and-call workflow fits the project and team.

The guidance below compares these pipelines head-to-head, gives practical selection rules, and closes with a pilot-to-production playbook. If you prefer to offload setup and tuning, our Population Genomics Sequencing Services, RAD-seq Bioinformatics Analysis, and ddRAD sequencing service can scope a pipeline, thresholds, and deliverables tailored to your organism and budget.

Why pipeline choice matters to real projects

Although Stacks 2, ipyrad, and dDocent aim at the same outcome—turning ddRAD reads into reliable variant calls—their assumptions differ in meaningful ways:

Overview of methods used in this study to process reduced representation sequencing data with reference genomes, with some alternatives to software used indicated where appropriate. (Wright et al., 2019, BMC Genomics)

• Clustering and locus definition. How reads are grouped into loci (and when a site "counts" across samples) changes the site-frequency spectrum and the total number of SNPs.
• Handling of indels and divergence. Tolerance to mismatches and small indels affects whether orthologous loci are recovered across divergent lineages.
• Paired-end information. Some pipelines can assemble longer loci by integrating paired-end reads, which can aid phasing and interpretation.
• Controls for missingness. Locus-presence thresholds and mapping/caller filters determine matrix completeness, which directly feeds into PCA/ADMIXTURE/STRUCTURE and F_ST.
• Compute and reproducibility. The ability to branch parameter sets, capture run metadata, and export standard formats reduces rework and improves reviewability.

A small, well-designed pilot helps you quantify these trade-offs on your own samples before you lock a recipe for production. You will see changes in per-sample call rates, locus length distributions, and SNP concordance across pipelines—differences that are often project-defining.

Number of polymorphic loci present in at least 75% of the individuals for different values of m (x axis). (Díaz-Arce & Rodríguez-Ezpeleta, 2019, Frontiers in Genetics)

Head-to-head: features and workflows you can act on

Feature & I/O snapshot

• Workflow modes
  • Stacks 2 runs de novo or reference-guided and is organised in modular steps (ending with gstacks and populations) that many labs already know.
  • ipyrad is primarily de novo (with reference-aware options), offers both a command-line interface and Python API, and supports notebook-driven analysis and MPI for clusters.
  • dDocent is a bash wrapper that sequences QC → assembly/mapping → variant calling, well suited to Linux environments and pragmatic teams.
• Paired-end & phasing
  • Stacks 2 can build short contigs from paired-end (PE) reads and merge them with single-end loci before genotyping. When your study benefits from longer loci or haplotype information, this capability is compelling.

Library preparation flowchart of MiddRAD protocol B and the original ddRAD protocol. (Yang et al., 2016, Plant Methods)

• Missing-data controls
  • Stacks 2: manage locus presence per population during export (e.g., require a locus to appear in a percentage of individuals within a population and across a minimum number of populations).
  • ipyrad: adjust min_samples_locus to control how many samples must carry a locus; tune clust_threshold to balance divergence tolerance and paralog avoidance.
  • dDocent: rely on mapping quality and variant-caller thresholds to limit noisy sites; choose PE vs RPE mode to match ddRAD/ezRAD vs sheared RAD protocols.
• Outputs & interoperability
  • All three export VCF. Stacks 2 and ipyrad also write PLINK/STRUCTURE-friendly formats and emit detailed logs and assembly statistics, which help satisfy reviewer requests and internal QA.

No-code, step-by-step workflows (pilot-oriented)

Stacks 2 (de novo → populations)

1. Demultiplex and clean reads to recover per-sample FASTQs.
2. Build per-sample loci and create a cohort-wide catalog.
3. Incorporate paired-end reads to assemble contigs; merge with single-end loci.
4. Call SNPs and genotypes across individuals/populations.
5. Export analysis-ready files (VCF, and where needed PLINK/STRUCTURE) and compile summary statistics.
   Practical note: when using PE ddRAD, report contig-length distributions and your locus-presence thresholds in Methods/QC so collaborators can track why certain loci were retained or dropped.

ipyrad (de novo / HPC-aware)

1. Create a project and parameter file that records demultiplexing, trimming, and data type (e.g., paired ddRAD).
2. Cluster reads and build consensus sequences with a sensible similarity threshold.
3. Assemble across samples and set min_samples_locus to balance locus count with matrix completeness; use a popfile if population-specific rules help your design.
4. Export standard formats (VCF, PLINK/STRUCTURE, EIGENSTRAT) together with rich assembly stats.
5. Scale on clusters using ipyrad's MPI workflow when cohorts are large or when you branch parameter sets.

dDocent (reference-guided map-and-call)

1. Quality-filter and trim reads inside the wrapper.
2. Choose data mode: PE for ddRAD/ezRAD (no random shearing) or RPE for sheared RAD.
3. Map to the reference with sensible mapping-quality thresholds, then call variants.
4. Export a VCF and review logs to check that mapping/caller filters fit your organism and library quality.

Practical selection rules

• You sequenced paired-end ddRAD and value longer loci or haplotypes → start with Stacks 2 and plan population-genetics exports from the outset.
• You manage many taxa/samples and want to explore parameter sensitivity on an HPC cluster → use ipyrad with MPI and notebooks for branching and versioned reproducibility.
• You have a usable reference and prefer a straightforward map-and-call approach → dDocent delivers a defensible callset with a familiar toolchain.

What the literature says about thresholds and bias

Comparative studies have shown that clustering cut-offs, missing-data rules, and filtering choices can alter diversity estimates and demographic fits. The robust strategy is not to search for a mythical "best" pipeline, but to run a documented, pilot-tested parameterisation and then hold it steady for production. A pilot with a small, representative subset will clarify trade-offs in SNP yield, call rates, and locus retention before you commit compute time and budget.

Average pairwise F_ST values for each catalog and population pairs for the three datasets. (Díaz-Arce & Rodríguez-Ezpeleta, 2019, Frontiers in Genetics)

FAQ: ddRAD pipeline selection

Choose your path

• Paired-end ddRAD with population-structure focus → choose Stacks 2; exploit PE contigs and export PLINK/STRUCTURE files for PCA/ADMIXTURE/STRUCTURE.
• Cross-taxon, cluster-scale projects → choose ipyrad; branch parameter sets with MPI and track decisions in notebooks under version control.
• Reference available and a map-and-call strategy fits → choose dDocent; start with conservative mapping/caller thresholds and relax as needed after a quick pilot.

Need a second pair of eyes? Our Population Genomics Sequencing Services align wet-lab design with your ddRAD bioinformatics. Our RAD-seq Bioinformatics Analysis team can implement Stacks 2, ipyrad, or dDocent to your specification, and our ddRAD sequencing service can advise on enzyme pairs and size selection so your chosen pipeline gets clean, analysis-ready data.

Next steps

1. Lock software versions and environment
   Write down exact versions (Stacks 2, ipyrad, dDocent), compilers, and cluster modules. For Stacks 2, note whether you used de novo or reference mode and whether paired-end reads were incorporated during locus assembly. For ipyrad, save the parameter file and any MPI settings. For dDocent, record whether you chose PE or RPE mode and which variant caller(s) were used. This one-page metadata sheet prevents confusion later.
2. Run a 10–20 sample pilot on identical read subsets
   Subsample the same reads across two candidate pipelines to keep the comparison fair. Compare:
   • loci per sample and per-locus depth,
   • locus-length distributions (especially for PE ddRAD),
   • per-sample call rate and missingness profile,
   • SNP concordance across pipelines, and
   • runtime and compute cost.
     Decide what trade-offs are acceptable for your aims (e.g., more loci vs a more complete matrix).
3. Tune thresholds systematically, not by hunch
   For Stacks 2, adjust population-level presence rules at export and observe how SNP yield and matrix completeness trade off. For ipyrad, sweep clust_threshold within a plausible window and step min_samples_locus to find a stable region. For dDocent, start with stringent mapping quality and caller filters; relax them gradually if call rates are low, keeping an eye on discordant sites. Keep a simple table of "settings → outcomes" so the final recipe is defensible.
4. Pre-define deliverables with stakeholders
   Agree early on VCF, PLINK, and STRUCTURE outputs, plus QC plots and parameter files. Stacks 2 and ipyrad both provide direct exporters and detailed statistics that are easy to include as supplementary files. Lock naming conventions and folder layouts so collaborators can navigate quickly, and so hand-offs to downstream modelling are painless.
5. Document every decision
   Maintain a runbook with the final parameter file(s), exact commands or notebooks, and key QC screenshots. This raises trust, accelerates manuscript writing, and satisfies reproducibility norms. If you later revisit demographic models or selection scans, that runbook will save hours.

Hands-on tips from the bioinformatics bench

• Library reality beats parameter ideology. Before tuning, inspect per-sample read counts, duplication, and basic QC. Remove or resequence outliers; do not contort thresholds to accommodate poor inputs.
• Paired-end is powerful, not magic. PE data can extend loci and sometimes enable phasing, but overly aggressive merging can drop otherwise valid loci. In Stacks 2 pilots, monitor contig length and locus retention as you change clustering settings.
• Use branching for learning, not for production. ipyrad's MPI/notebook workflow is superb for exploring sensitivity. Once you commit to settings, re-assemble the full dataset in a clean branch so your production run is auditable.
• Reference quality exists on a spectrum. A draft reference can still help in dDocent; choose mapping thresholds thoughtfully and be explicit about limitations in your Methods.
• Think downstream early. If your end goal is structure inference, decide LD pruning and per-SNP missingness rules now and ensure your pipeline exports PLINK/STRUCTURE-ready outputs.

Ready to move from comparison to implementation?

If you want a scoped plan that lines up inputs, thresholds, compute, and deliverables, contact our team through Population Genomics Sequencing Services or RAD-seq Bioinformatics Analysis. If you are still refining wet-lab details, our ddRAD sequencing service can advise on enzyme pairs and size selection so your chosen pipeline gets clean, analysis-ready data.

Related Reading:

• ddRAD-Seq 101: Enzyme Choice & Size Selection
• GBS vs RAD vs ddRAD: Which Method Fits Your Project
• Population Structure with ddRAD: PCA, ADMIXTURE & STRUCTURE
• ddRAD for Plants: A Practical Manual for Non-Model Crops
• Designing ddRAD Projects: Expected Loci, Coverage Models & Budget
• Low-Coverage WGS + ANGSD vs ddRAD: When to Replace, When to Complement