I created a local subworkflow to enable the watching of an output directory of one pipeline (using the

.watchPath

channel factory) for specific output files that can be used as input files for the current pipeline. Do you think it would benefit to others if I push this to nf-core? (source code: https://github.com/nvnieuwk/nextflow-watchpath-samplesheet)

Hello! I want to add a new subworkflow, but I am not sure about my choice on the name… The idea is to use this subworkflow to take some input and run the chosen functional enrichment analysis (eg. GSEA, gprofiler, etc) on it. I have thought about

differential_functional_enrichment

, but this subworkflow can also take expression data directly as input, or graph matrix instead of differential expression results as input. Also, as an optional step, a gene set file can be produced based on the input data before running the functional analysis. Any recommendation?

Hello, I am adding a subworkflow, the modules are already in place: index, map, merge, extract and estimate. The basic pipeline is map->_extract_->_estimate_. However, index is only needed initially to index the database(s), and merge is only needed if something is mapped to two different databases and one needs to merge the mapping into a single bam file before running extract. How should I add the modules in the subworkflow?

Hmmm, I think that FASTQ_ALIGN_BWA is somewhat suboptimal. BWA_MEM has an option to sort the bam directly inside the process, controlled by the sort_bam option to the subworkflow. But then BAM_SORT_STATS_SAMTOOLS is called, which will then sort the bam file.

Hi folks! Quick design quesiton if I would want to write an nf-core subworkflow: I need some auxiliar groovy functions. Where would they belong ideally in your opinion? Define before the workflow or in a separate utils.nf? A

// Define the function at the top
def myFunction(value) {
    return value.toUpperCase()
}

workflow myWorkflow {
    def result = myFunction("hello")
    println "Result: $result"
}

or B

include { myFunction } from './utils.nf'

workflow myWorkflow {
    def result = myFunction("hello")
    println "Result: $result"
}

Oi @Jonathan Manning (I assume) fix your nf-core subworkflows!

╰──────────────────────────────────────────────────────────────────────────────╯
╭─ [✗] 11 Subworkflow Tests Failed ────────────────────────────────────────────╮
│                                                    ╷            ╷            │
│                                                    │            │ Test       │
│ Subworkflow name                                   │ File path  │ message    │
│╶───────────────────────────────────────────────────┼────────────┼───────────╴│
│ differential_functional_enrichment                 │ subworkfl… │ Included   │
│                                                    │            │ module/sub │
│                                                    │            │ workflow   │
│                                                    │            │ custom/tab │
│                                                    │            │ ulartogsea │
│                                                    │            │ chip       │
│                                                    │            │ missing in │
│                                                    │            │ meta.yml   │
│ differential_functional_enrichment                 │ subworkfl… │ Included   │
│                                                    │            │ module/sub │
│                                                    │            │ workflow   │
│                                                    │            │ custom/tab │
│                                                    │            │ ulartogsea │
│                                                    │            │ cls        │
│                                                    │            │ missing in │
│                                                    │            │ meta.yml   │
│ differential_functional_enrichment                 │ subworkfl… │ Included   │
│                                                    │            │ module/sub │
│                                                    │            │ workflow   │
│                                                    │            │ custom/tab │
│                                                    │            │ ulartogsea │
│                                                    │            │ gct        │
│                                                    │            │ missing in │
│                                                    │            │ meta.yml   │
│ fastq_qc_trim_filter_setstrandedness               │ subworkfl… │ Included   │
│                                                    │            │ module/sub │
│                                                    │            │ workflow   │
│                                                    │            │ fq/lint    │
│                                                    │            │ missing in │
│                                                    │            │ meta.yml   │
│ abundance_differential_filter                      │ subworkfl… │ The        │
│                                                    │            │ meta.yml   │
│                                                    │            │ of the     │
│                                                    │            │ subworkflo │
│                                                    │            │ w          │
│                                                    │            │ abundance_ │
│                                                    │            │ differenti │
│                                                    │            │ al_filter  │
│                                                    │            │ is not     │
│                                                    │            │ valid:     │
│                                                    │            │ 'name' is  │
│                                                    │            │ a required │
│                                                    │            │ property.  │
│ utils_nextflow_pipeline                            │ subworkfl… │ test       │
│                                                    │            │ main.nf.te │
│                                                    │            │ st does    │
│                                                    │            │ not exist  │
│ utils_nfcore_pipeline                              │ subworkfl… │ test       │
│                                                    │            │ main.nf.te │
│                                                    │            │ st does    │
│                                                    │            │ not exist  │
│ bam_dedup_umi                                      │ subworkfl… │ Tags do    │
│                                                    │            │ not adhere │
│                                                    │            │ to         │
│                                                    │            │ guidelines │
│                                                    │            │ . Tags     │
│                                                    │            │ missing in │
│                                                    │            │ main.nf.te │
│                                                    │            │ st:        │
│                                                    │            │ ['subworkf │
│                                                    │            │ lows/bam_s │
│                                                    │            │ ort_stats_ │
│                                                    │            │ samtools', │
│                                                    │            │            │
│                                                    │            │ 'subworkfl │
│                                                    │            │ ows/bam_de │
│                                                    │            │ dup_stats_ │
│                                                    │            │ samtools_u │
│                                                    │            │ micollapse │
│                                                    │            │ ',         │
│                                                    │            │ 'subworkfl │
│                                                    │            │ ows/bam_de │
│                                                    │            │ dup_stats_ │
│                                                    │            │ samtools_u │
│                                                    │            │ mitools']  │
│ differential_functional_enrichment                 │ subworkfl… │ Tags do    │
│                                                    │            │ not adhere │
│                                                    │            │ to         │
│                                                    │            │ guidelines │
│                                                    │            │ . Tags     │
│                                                    │            │ missing in │
│                                                    │            │ main.nf.te │
│                                                    │            │ st:        │
│                                                    │            │ ['custom/t │
│                                                    │            │ abulartogs │
│                                                    │            │ eagct',    │
│                                                    │            │ 'custom/ta │
│                                                    │            │ bulartogse │
│                                                    │            │ achip',    │
│                                                    │            │ 'custom/ta │
│                                                    │            │ bulartogse │
│                                                    │            │ acls',     │
│                                                    │            │ 'abundance │
│                                                    │            │ _different │
│                                                    │            │ ial_filter │
│                                                    │            │ ']         │
│ fastq_qc_trim_filter_setstrandedness               │ subworkfl… │ Tags do    │
│                                                    │            │ not adhere │
│                                                    │            │ to         │
│                                                    │            │ guidelines │
│                                                    │            │ . Tags     │
│                                                    │            │ missing in │
│                                                    │            │ main.nf.te │
│                                                    │            │ st:        │
│                                                    │            │ ['fq/lint' │
│                                                    │            │ ]          │
│ differential_functional_enrichment                 │ subworkfl… │ md5sum for │
│                                                    │            │ empty file │
│                                                    │            │ found:     │
│                                                    │            │ d41d8cd98f │
│                                                    │            │ 00b204e980 │
│                                                    │            │ 0998ecf842 │
│                                                    │            │ 7e         │
│                                                    ╵            ╵            │
╰──────────────────────────────────────────────────────────────────────────────╯

😉 😉 😉 😉 😉 😉

Must all modules of a nf-core subworkflow be also nf-core modules?

I am working on a new subworkflow for sarek that might also be compatible as a standalone nf-core subworkflow (needs to be decided later maybe). I have a lot of channel manipulation in the workflow and was wondering if any of you nextflow wizards 🧙 might have some time to have a look and give me some hints to improve the code readability etc.. You can check all files but the main coding I did is in this file: https://github.com/nf-core/sarek/pull/1940/files#diff-0c37c0cc0dcb7acea8f72c4f99b0677d9239ca949642bd0b4a91b50264faaf9e A few comments or hints would already help me a lot 🙂

Hi! Can I get some input on the name for a new subworkflow I want to add? Currently it is called

FASTQ_ALIGN_CONVERT_STAR_SAMTOOLS

since there is already a subworkflow called

FASTQ_ALIGN_STAR

. Thank you!

Hi, if anyone has some time to review a new subworkflow I’d like to add that would be much appreciated! It runs a complete cell segmentation from the vizgenpostprocessing modules I’ve added to nf-core

Hi, I have an issue with a version.yml as a result of "competing" subworkflows. It seems to me that conda versus docker/singularity pick different recursive routes to include subworkflows (see "installed_by" of modules.json). Now, when I launch my pipeline the exact same way and only change singularity to conda as profile, the subworkflows are imported differently (see comparison of version.yml). Is that a known phenomenon? Might be a case for #C049MBCEW06 too

I am trying to convert my

EXECUTE_CLUSTERING

local subworkflow to an nf-core one:

MMSEQS_FASTA_CLUSTER

. Is there a way to use a patched nf-core/module in an nf-core subworkflow? I want to use stageAs aliases in the inputs to avoid executing a module twice, the way it's done here: https://github.com/nf-core/proteinfamilies/blob/main/modules/nf-core/mmseqs/createtsv/main.nf Otherwise I would have to execute

MMSQES_CREATEDB

twice, which is a huge waste of resources and unnecessary code duplication. If not, is there a smarter way? We could always update the module to always use stageAs.. @Joon Klaps, @Jasmin Frangenberg?

Hello! I am looking into adding

versions.yaml

from different processes, and combining them together with

params

into a table in the final

multiqc

report. I am trying to make this more FAIR and I am wondering if anyone already has done something similar and/or is using a certain standardised template for this? I was looking into RO-crate , but I couldn't really find a template for versions & params?

When I need to access a parameter in a subworkflow, is it preferred to access

params

or to accept that as an input to the workflow? I prefer the latter to avoid global magic, but

params

are much easier to set up.

Beginner question, how do I test a local subworkflow?

❯ nf-core subworkflows test --profile docker sourmash_create


                                          ,--./,-.
          ___     __   __   __   ___     /,-._.--~\
    |\ | |__  __ /  ` /  \ |__) |__         }  {
    | \| |       \__, \__/ |  \ |___     \`-._,-`-,
                                          `._,._,'

    nf-core/tools version 3.3.2 - <https://nf-co.re>


CRITICAL Cannot find directory 'subworkflows/nf-core/sourmash_create'.

Assumes that it's an nf-core one...

And another question about subworkflows, is it now preferred to publish outputs from the workflow or still from the individual processes?

@Eduard Casas is suggesting to add

METHYLDACKEL_EXTRACT_MBIAS

as a new subworkflow. This takes a bam, so potentially wants to start with BAM for consistency. Eduard, are there any other methyldackel tools that might be added in time? Basically naming subworkflows is harder than modules, because we don't tend to want to rename them after creation.

I also want to add a new subworkflow to be used in the #CP3RJSMF0 pipeline: this workflow will use the newly implemented rastair modules to assess methylated C to T conversion rates as a positive readout of DNA methylation. I was thinking of the name TAPS_CONVERSION given how the protocol to generate this data is called TAPS (Tet-assisted pyridine borane sequencing). The input will be a bam file (+ bam index, fasta, fa.fai) and the output some plain text files (.bed, .txt) and pdf and .gz. So if we want to call it BAM_TAPS_CONVERSION we are also fine with it. Thoughts?

Any thoughts on the name of this subworkflow: https://github.com/nf-core/modules/pull/9067 Currently FASTA_INDEX_BISMARK_BWAMETH_BWAMEM

Hello! I recently added a bunch of modules from the 'rastair' toolkit (rastair/call, rastair/mbias, rastair/mbias_parser...) which are used within the recently added subworkflow bam_taps_conversion. However, when installing this subworkflow through the nf-core toolkit I get this error: ~/methylseq$ nf-core subworkflows install bam_taps_conversion INFO Installing 'bam_taps_conversion' ERROR Module 'rastair/mbias/parser' not found in available modules The issue I can see here is that the toolkit is is reading the underscore in the module name as a backslash, hence not finding it, even though I can install such workflow using nf-core modules install rastair/mbias_parser Is there a way to still install that subworkflow through the nf-core CLI or should I make a PR and rename the module removing the underscore? Thanks! Slack conversation

New

fastq

file sanitization/pre-processing subworkflow, to be used instead of just

seqkit/sana

, that automatically breaks paired-end reads (

seqkit/sana

can only process one file at a time), mixes with single-end reads in one channel, runs

seqkit/sana

and finally merges back original pairs with `seqkit/pair`; https://github.com/nf-core/modules/pull/9185

Regarding the upcoming hackathon (https://nf-co.re/events/2025/hackathon-barcelona)

extended short reads QC subworkflow

project; how does the name

fastq_shortreads_preprocess_qc

for the new subworkflow sound like? Any strong opinions against it? If so, feel free to suggest any alternatives

Got a new subworkflow request here (pending review): https://github.com/nf-core/modules/pull/9197 bascically wraps fastq_align_bwa but includes parabricks/fq2bam and some stats and deduplication

Hi. On the nf-core webpage there is a list of available subworkflows. Two of them are • fastq_generate_statistics • fastq_qc_stats Both subworkflows do basically the same, except that fastq_generate_statistics can't be installed. It is also not available if one runs

$ nf-core subworkflows list remote

The

qc

subworkflow is available, the `generate`is not. Is there any way to synchronise webpage and github?

Can I get another round of review on this one please -> https://github.com/nf-core/modules/pull/10549

Hi all. I want to better understand how nf-core subworkflows are tested on the GitHub CI. I notice a lot of breaking changes keep getting merged and go undiscovered until you go to update one of the modules they touch. To me, it looks like the CI runners aren't running the subworkflow tests properly, but I want to know if this is expected behavior. For context, see this issue. @Kevin Brockers for viz

I'm writing a subworkflow that I intend to contribute to the nf-core collection in due time. This of course means that the individual modules should also be submitted if they're not already there. However, there is at least one step that is highly specific for the subworkflow (checking that sequence names in the two types of input files are the same). Would it be OK to include a process definition in the swf?

Anyone want to help @Sarath Murugan name the GRIDSS subworkflow in github.com/nf-core/modules/pull/12574 I feel that

bam_tumor_normal_somatic_structural_variant_calling_gridss

is a bit excessive

A subworkflow for

unzipping fasta, cleaning and then index/sizes generation

(and I'd suggest dict generation too) : github.com/nf-core/modules/pull/12663 definitely not

GUNZIP_FASTA_INDEX

, because

FASTA

should be first.

I'm writing the above subworkflow. Are groovy functions which read a file something that should be avoided and replaced with a module? For example

// Read the .fai file to extract the number of sequences, the maximum and total sequence length
// Inspired from <https://github.com/nf-core/rnaseq/blob/3.10.1/lib/WorkflowRnaseq.groovy>
def get_sequence_map(fai_file) {
    def n_sequences = 0
    def max_length = 0
    def total_length = 0
    fai_file.eachLine { line ->
        def lspl = line.split('\t')
        // def chrom  = lspl[0]
        def length = lspl[1].toLong()
        n_sequences += 1
        total_length += length
        if (length > max_length) {
            max_length = length
        }
    }

    def sequence_map = [:]
    sequence_map.n_sequences = n_sequences
    sequence_map.total_length = total_length
    if (n_sequences) {
        sequence_map.max_length = max_length
    }
    return sequence_map
}

It's a really small function which will be modified to generate a JSON file instead so we don't pollute meta. It's not doing much so is it worth a module?