diff --git a/.codeboarding/Bioinformatics_Workflows_Tools.md b/.codeboarding/Bioinformatics_Workflows_Tools.md
new file mode 100644
index 0000000..09a6602
--- /dev/null
+++ b/.codeboarding/Bioinformatics_Workflows_Tools.md
@@ -0,0 +1,259 @@
+```mermaid
+
+graph LR
+
+ Bioinformatics_Workflows_Tools["Bioinformatics Workflows & Tools"]
+
+ Main_Workflows["Main Workflows"]
+
+ Subworkflows["Subworkflows"]
+
+ Atomic_Modules["Atomic Modules"]
+
+ Containerization_and_Environment_Management["Containerization and Environment Management"]
+
+ External_Tool_Integration_Layer["External Tool Integration Layer"]
+
+ Data_Access_Layer["Data Access Layer"]
+
+ Configuration_Management["Configuration Management"]
+
+ Error_Handling_and_Logging["Error Handling and Logging"]
+
+ Data_Schema_and_Validation["Data Schema and Validation"]
+
+ Bioinformatics_Workflows_Tools -- "orchestrates" --> Main_Workflows
+
+ Bioinformatics_Workflows_Tools -- "integrates with" --> External_Tool_Integration_Layer
+
+ Bioinformatics_Workflows_Tools -- "interacts with" --> Data_Access_Layer
+
+ Bioinformatics_Workflows_Tools -- "consumes" --> Configuration_Management
+
+ Bioinformatics_Workflows_Tools -- "reports to" --> Error_Handling_and_Logging
+
+ Bioinformatics_Workflows_Tools -- "adheres to" --> Data_Schema_and_Validation
+
+ Main_Workflows -- "composes" --> Subworkflows
+
+ Main_Workflows -- "depends on" --> Containerization_and_Environment_Management
+
+ Subworkflows -- "composes" --> Atomic_Modules
+
+ Subworkflows -- "depends on" --> Containerization_and_Environment_Management
+
+ Atomic_Modules -- "utilizes" --> Containerization_and_Environment_Management
+
+ Atomic_Modules -- "wraps" --> External_Tool_Integration_Layer
+
+ click Bioinformatics_Workflows_Tools href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//Bioinformatics_Workflows_Tools.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+Overview of the Bioinformatics Workflows & Tools component, detailing its structure, flow, purpose, and interactions with other parts of the system.
+
+
+
+### Bioinformatics Workflows & Tools [[Expand]](./Bioinformatics_Workflows_Tools.md)
+
+The top-level component responsible for orchestrating and executing complex bioinformatics pipelines using Nextflow. It acts as the central hub for all genomic data processing, ensuring reproducibility and scalability.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `main.nf` (1:1)
+
+- `workflows/` (1:1)
+
+- `subworkflows/` (1:1)
+
+- `modules/` (1:1)
+
+- `genome_manager/Dockerfile` (1:1)
+
+- `genome_manager/env.yaml` (1:1)
+
+
+
+
+
+### Main Workflows
+
+High-level Nextflow scripts that define complete, end-to-end bioinformatics pipelines for specific use cases (e.g., adding a new genome). They serve as the primary entry points for users to initiate complex operations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `main.nf` (1:1)
+
+- `workflows/add_genome.nf` (1:1)
+
+- `workflows/register_user_defined_gene.nf` (1:1)
+
+- `workflows/update_user_defined_gene.nf` (1:1)
+
+
+
+
+
+### Subworkflows
+
+Intermediate Nextflow scripts that encapsulate common sequences of atomic modules. They promote code reusability and modularity by breaking down complex main workflows into manageable, logical steps.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `subworkflows/prep_genome.nf` (1:1)
+
+- `subworkflows/make_picard_files.nf` (1:1)
+
+- `load_genome_extra_files/subworkflows/load_genome.nf` (1:1)
+
+
+
+
+
+### Atomic Modules
+
+The smallest, self-contained units of work within the Nextflow ecosystem. Each module typically wraps a single external bioinformatics tool or performs a very specific data manipulation step, ensuring high reusability and testability.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `modules/genome_manager/download_genome/download_genome.nf` (1:1)
+
+- `modules/genome_manager/register_genome/register_genome.nf` (1:1)
+
+- `modules/genome_manager/register_gene/register_gene.nf` (1:1)
+
+- `modules/genome_manager/update_gene/update_gene.nf` (1:1)
+
+- `modules/star/genomegenerate/main.nf` (1:1)
+
+- `load_genome_extra_files/modules/custom/gtf2gff3/gtf2gff3.nf` (1:1)
+
+- `modules/unpigz/unpigz.nf` (1:1)
+
+- `modules/gffread/to_transcriptome/main.nf` (1:1)
+
+- `modules/nf-core/custom/dumpsoftwareversions/main.nf` (1:1)
+
+
+
+
+
+### Containerization and Environment Management
+
+This component defines and manages the isolated execution environments for all bioinformatics tasks. It leverages Docker for containerization and Conda/Mamba (via `env.yaml`) for precise dependency management, ensuring workflow reproducibility and portability across different systems.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager/Dockerfile` (1:1)
+
+- `genome_manager/env.yaml` (1:1)
+
+
+
+
+
+### External Tool Integration Layer
+
+Represents the interface and mechanisms through which the Nextflow modules interact with and execute external bioinformatics command-line tools (e.g., STAR, Picard, GFFread).
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Data Access Layer
+
+Handles the reading and writing of genomic data (e.g., FASTA, GTF, GFF files) and metadata to and from the underlying data storage. Workflows interact with this layer to retrieve input data and persist results.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Configuration Management
+
+Manages all configurable parameters for the workflows, including paths to reference data, tool-specific settings, and execution profiles. This ensures flexibility and adaptability of the workflows without modifying source code.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Error Handling and Logging
+
+Provides mechanisms for capturing, reporting, and logging errors and execution events from the Nextflow workflows and underlying tools. This is critical for debugging, monitoring, and ensuring the reliability of long-running bioinformatics tasks.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Data Schema and Validation
+
+Defines the expected structure and format of input and output data for workflows and modules. It includes mechanisms to validate data against these schemas, ensuring data quality and compatibility throughout the pipeline.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/CLI_Application_Orchestration.md b/.codeboarding/CLI_Application_Orchestration.md
new file mode 100644
index 0000000..8a511d4
--- /dev/null
+++ b/.codeboarding/CLI_Application_Orchestration.md
@@ -0,0 +1,179 @@
+```mermaid
+
+graph LR
+
+ CLI_Application_Orchestration["CLI & Application Orchestration"]
+
+ Data_Schema_and_Validation["Data Schema and Validation"]
+
+ File_and_Data_Integrity_Checkers["File and Data Integrity Checkers"]
+
+ GTF_Entry_Generation["GTF Entry Generation"]
+
+ Error_Handling_and_Logging["Error Handling and Logging"]
+
+ Configuration_Management["Configuration Management"]
+
+ CLI_Application_Orchestration -- "orchestrates" --> Data_Schema_and_Validation
+
+ CLI_Application_Orchestration -- "orchestrates" --> File_and_Data_Integrity_Checkers
+
+ CLI_Application_Orchestration -- "orchestrates" --> GTF_Entry_Generation
+
+ CLI_Application_Orchestration -- "reports to" --> Error_Handling_and_Logging
+
+ CLI_Application_Orchestration -- "orchestrates" --> Configuration_Management
+
+ click CLI_Application_Orchestration href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//CLI_Application_Orchestration.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `CLI & Application Orchestration` component serves as the primary interface and control center for the genomic data management system. It is responsible for interpreting user commands, validating initial inputs, and directing the flow of execution to either core Python data management functions or Nextflow workflows. This component is fundamental because it provides the user-facing entry point, ensuring that all operations are initiated correctly and routed to the appropriate backend logic, thereby maintaining system integrity and user experience.
+
+
+
+### CLI & Application Orchestration [[Expand]](./CLI_Application_Orchestration.md)
+
+This component is the system's command-line interface, built around `argparse` for robust argument parsing. It acts as the central dispatcher, validating user inputs against defined schemas and orchestrating the execution of various data management tasks. These tasks include registering new genomes, listing existing genomic data, generating GTF entries from YAML specifications, and initiating complex Nextflow workflows for data processing. It integrates error handling and logging to provide a resilient and informative user experience.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.main`
+
+- `argparse.ArgumentParser`
+
+- `genome_manager.register_genome` (1232:1247)
+
+- `genome_manager.list_genomes` (1561:1609)
+
+- `genome_manager.generate_gtf_entry.generate_gtf_entry_from_yaml`
+
+
+
+
+
+### Data Schema and Validation
+
+Handles data validation using Pydantic schemas.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Pydantic.GenomeFile`
+
+- `Pydantic.GenomeMetadata`
+
+- `Pydantic.YamlGeneModel`
+
+- `Pydantic.YamlGeneCollection`
+
+
+
+
+
+### File and Data Integrity Checkers
+
+Ensures the validity and integrity of files and data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `GenomeFile.checksum_validation`
+
+- `globber`
+
+
+
+
+
+### GTF Entry Generation
+
+Converts YAML gene models into GTF format.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.generate_gtf_entry.generate_gtf_entry_from_yaml`
+
+
+
+
+
+### Error Handling and Logging
+
+Manages error reporting and system logging.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `logging`
+
+- `logging.logger.info`
+
+- `logging.logger.exception`
+
+
+
+
+
+### Configuration Management
+
+Handles loading and interpreting system configuration.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.load_mount_config` (622:627)
+
+- `genome_manager.find_active_system` (512:527)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Genome_Data_Management_Core.md b/.codeboarding/Genome_Data_Management_Core.md
new file mode 100644
index 0000000..f7a8a6c
--- /dev/null
+++ b/.codeboarding/Genome_Data_Management_Core.md
@@ -0,0 +1,63 @@
+```mermaid
+
+graph LR
+
+ Genome_Registry_Manager["Genome Registry Manager"]
+
+ Gene_Metadata_Processor["Gene Metadata Processor"]
+
+ Genome_Registry_Manager -- "uses" --> Gene_Metadata_Processor
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The Genome Data Management Core subsystem is designed to be the central hub for managing genomic and gene-related metadata within the project. It ensures data integrity, provides structured access to genomic resources, and facilitates the integration of custom gene annotations.
+
+
+
+### Genome Registry Manager
+
+This component is responsible for the core operations of managing genome assembly metadata and associated files. It handles the registration, updating, and retrieval of genome information, including file paths, checksums, and metadata. It also performs data validation against defined schemas and integrates with the gene metadata management for comprehensive data integrity. This component acts as the primary interface for interacting with the stored genome reference data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.generate_gtf_entry.YamlGeneCollection` (44:47)
+
+- `genome_manager.generate_gtf_entry.YamlGeneModel` (29:42)
+
+
+
+
+
+### Gene Metadata Processor
+
+This component focuses on the detailed management and processing of gene-level metadata. It defines the schema for gene models (exons, transcripts, CDS) in YAML format and provides utilities to validate and potentially transform this data into standard bioinformatics formats like GTF. It's a critical part of ensuring that user-defined or external gene annotations are correctly structured and integrated into the overall genomic data landscape.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Nextflow_Workflow_Engine.md b/.codeboarding/Nextflow_Workflow_Engine.md
new file mode 100644
index 0000000..0cf13a5
--- /dev/null
+++ b/.codeboarding/Nextflow_Workflow_Engine.md
@@ -0,0 +1,183 @@
+```mermaid
+
+graph LR
+
+ Main_Workflow_Orchestrator["Main Workflow Orchestrator"]
+
+ Nextflow_Configuration_Manager["Nextflow Configuration Manager"]
+
+ Core_Workflow_Libraries_Groovy_["Core Workflow Libraries (Groovy)"]
+
+ Atomic_Nextflow_Modules["Atomic Nextflow Modules"]
+
+ Reusable_Nextflow_Subworkflows["Reusable Nextflow Subworkflows"]
+
+ Specific_Nextflow_Workflows["Specific Nextflow Workflows"]
+
+ Main_Workflow_Orchestrator -- "Uses" --> Nextflow_Configuration_Manager
+
+ Main_Workflow_Orchestrator -- "Orchestrates" --> Reusable_Nextflow_Subworkflows
+
+ Main_Workflow_Orchestrator -- "Orchestrates" --> Atomic_Nextflow_Modules
+
+ Main_Workflow_Orchestrator -- "Interacts with" --> Core_Workflow_Libraries_Groovy_
+
+ Nextflow_Configuration_Manager -- "Configures" --> Atomic_Nextflow_Modules
+
+ Nextflow_Configuration_Manager -- "Configures" --> Reusable_Nextflow_Subworkflows
+
+ Core_Workflow_Libraries_Groovy_ -- "Supports" --> Main_Workflow_Orchestrator
+
+ Core_Workflow_Libraries_Groovy_ -- "Supports" --> Atomic_Nextflow_Modules
+
+ Atomic_Nextflow_Modules -- "Configured by" --> Nextflow_Configuration_Manager
+
+ Reusable_Nextflow_Subworkflows -- "Composes" --> Atomic_Nextflow_Modules
+
+ Reusable_Nextflow_Subworkflows -- "Used by" --> Main_Workflow_Orchestrator
+
+ Specific_Nextflow_Workflows -- "Composes" --> Reusable_Nextflow_Subworkflows
+
+ Specific_Nextflow_Workflows -- "Composes" --> Atomic_Nextflow_Modules
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+Abstract Components Overview
+
+
+
+### Main Workflow Orchestrator
+
+This is the entry point and primary control flow for the entire Nextflow pipeline. It defines the high-level sequence of operations, orchestrating the execution of various subworkflows and individual modules to achieve the overall pipeline objective. It acts as the central coordinator, ensuring processes run in the correct order and dependencies are met.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `main.nf` (1:1)
+
+
+
+
+
+### Nextflow Configuration Manager
+
+This component is responsible for managing all execution-related parameters, resource allocations, and environment settings for the Nextflow pipeline. It consolidates configurations from `nextflow.config` (global settings), `conf/modules.config` (module-specific overrides), and `conf/profiles.config` (environment-specific profiles like Docker, Conda, HPC clusters). This ensures reproducibility and adaptability across different execution environments.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `nextflow.config` (1:1)
+
+- `modules.config` (1:1)
+
+- `profiles.config` (1:1)
+
+
+
+
+
+### Core Workflow Libraries (Groovy)
+
+These Groovy scripts provide reusable helper functions, complex data manipulation logic, or utility classes that extend the capabilities of the Nextflow DSL. They encapsulate common, non-pipeline-specific logic that can be invoked by various Nextflow processes or workflows, promoting code reuse and separation of concerns.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `WorkflowMain.groovy` (1:1)
+
+- `WorkflowAddGenome.groovy` (1:1)
+
+
+
+
+
+### Atomic Nextflow Modules
+
+These are the smallest, self-contained units of work within the Nextflow ecosystem. Each module typically encapsulates a single bioinformatics tool or a specific, atomic processing step (e.g., `bwa_index`, `samtools_sort`). They are designed to be highly reusable and independent, taking specific inputs and producing specific outputs.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `modules/custom/*/*.nf` (1:1)
+
+- `modules/genome_manager/*/*.nf` (1:1)
+
+- `load_genome_extra_files/modules/custom/*.nf` (1:1)
+
+
+
+
+
+### Reusable Nextflow Subworkflows
+
+Subworkflows combine multiple atomic modules into a larger, logical sequence of operations that can be reused across different main workflows. They represent common patterns or multi-step processes (e.g., "align and sort reads," "perform variant calling"). This abstraction reduces redundancy and improves pipeline readability.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `subworkflows/*.nf` (1:1)
+
+- `load_genome_extra_files/subworkflows/load_genome.nf` (1:1)
+
+
+
+
+
+### Specific Nextflow Workflows
+
+These are complete, end-to-end pipelines tailored for specific use cases or analyses within the Genomic Reference Data Hub. They typically integrate various subworkflows and atomic modules, often defined in the `workflows/` directory, to achieve a particular biological or genomic objective.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `workflows/*.nf` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 0000000..11632d0
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,199 @@
+```mermaid
+
+graph LR
+
+ CLI_Application_Orchestration["CLI & Application Orchestration"]
+
+ Genome_Data_Management_Core["Genome Data Management Core"]
+
+ Data_Schema_Registry["Data Schema & Registry"]
+
+ Nextflow_Workflow_Engine["Nextflow Workflow Engine"]
+
+ Bioinformatics_Workflows_Tools["Bioinformatics Workflows & Tools"]
+
+ CLI_Application_Orchestration -- "Invokes/Triggers" --> Genome_Data_Management_Core
+
+ CLI_Application_Orchestration -- "Invokes/Triggers" --> Nextflow_Workflow_Engine
+
+ Genome_Data_Management_Core -- "Provides Data/Status to" --> CLI_Application_Orchestration
+
+ Genome_Data_Management_Core -- "Uses/Validates with" --> Data_Schema_Registry
+
+ Genome_Data_Management_Core -- "Prepares Data for" --> Nextflow_Workflow_Engine
+
+ Data_Schema_Registry -- "Defines/Validates" --> Genome_Data_Management_Core
+
+ Data_Schema_Registry -- "Provides Configuration/Schema to" --> Nextflow_Workflow_Engine
+
+ Data_Schema_Registry -- "Stores/Retrieves" --> Bioinformatics_Workflows_Tools
+
+ Nextflow_Workflow_Engine -- "Reports Status to" --> CLI_Application_Orchestration
+
+ Nextflow_Workflow_Engine -- "Orchestrates/Executes" --> Bioinformatics_Workflows_Tools
+
+ Nextflow_Workflow_Engine -- "Reads Configuration from" --> Data_Schema_Registry
+
+ Bioinformatics_Workflows_Tools -- "Executed by" --> Nextflow_Workflow_Engine
+
+ Bioinformatics_Workflows_Tools -- "Accesses/Stores Data in" --> Data_Schema_Registry
+
+ click CLI_Application_Orchestration href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//CLI_Application_Orchestration.md" "Details"
+
+ click Genome_Data_Management_Core href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//Genome_Data_Management_Core.md" "Details"
+
+ click Nextflow_Workflow_Engine href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//Nextflow_Workflow_Engine.md" "Details"
+
+ click Bioinformatics_Workflows_Tools href "https://github.com/pfizer-opensource/genome-manager/blob/main/.codeboarding//Bioinformatics_Workflows_Tools.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `genome-manager` project is architected as a robust Bioinformatics Data Management System with integrated workflow automation. The system is designed for clear separation of concerns, modularity, and reproducibility, leveraging Python for core data management and Nextflow for complex bioinformatics workflows.
+
+
+
+### CLI & Application Orchestration [[Expand]](./CLI_Application_Orchestration.md)
+
+The primary user interface, responsible for parsing command-line arguments, validating initial input, and orchestrating the execution of either core Python data management functions or Nextflow workflows. It acts as the central dispatcher for user commands.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.py` (1:1)
+
+
+
+
+
+### Genome Data Management Core [[Expand]](./Genome_Data_Management_Core.md)
+
+Encapsulates the core business logic for managing genomic and gene metadata. This includes operations like reading, writing, and updating genome and gene registry files (JSON/YAML), performing data integrity checks, and preparing data structures for downstream processing. It also includes Python utilities for data transformation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.py` (1:1)
+
+- `generate_gtf_entry.py` (1:1)
+
+
+
+
+
+### Data Schema & Registry
+
+Defines and enforces the structural integrity and validation rules for all managed data, including genome assemblies, associated files, gene models, and Nextflow pipeline parameters. It also manages the physical storage and organization of all genomic data files and internal configuration registries.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `genome_manager.py` (1:1)
+
+- `nextflow_schema.json` (1:1)
+
+- `NfcoreSchema.groovy` (1:1)
+
+- `modules.config` (1:1)
+
+- `profiles.config` (1:1)
+
+
+
+
+
+### Nextflow Workflow Engine [[Expand]](./Nextflow_Workflow_Engine.md)
+
+The central orchestration component for complex bioinformatics pipelines. It interprets and executes Nextflow scripts, manages process dependencies, handles resource allocation, and integrates various modules and subworkflows to perform multi-step tasks. It also reads and applies pipeline configurations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `main.nf` (1:1)
+
+- `WorkflowMain.groovy` (1:1)
+
+- `WorkflowAddGenome.groovy` (1:1)
+
+- `nextflow.config` (1:1)
+
+- `modules.config` (1:1)
+
+- `profiles.config` (1:1)
+
+
+
+
+
+### Bioinformatics Workflows & Tools [[Expand]](./Bioinformatics_Workflows_Tools.md)
+
+Provides reusable, atomic units of bioinformatics processing logic (modules) and combinations of modules for common patterns (subworkflows). These perform specific, granular tasks like downloading files, generating genome indices, or converting file formats, often leveraging containerized external bioinformatics tools.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `add_genome.nf` (1:1)
+
+- `register_user_defined_gene.nf` (1:1)
+
+- `update_user_defined_gene.nf` (1:1)
+
+- `download_genome.nf` (1:1)
+
+- `register_genome.nf` (1:1)
+
+- `main.nf` (1:1)
+
+- `gtf2gff3.nf` (1:1)
+
+- `prep_genome.nf` (1:1)
+
+- `load_genome.nf` (1:1)
+
+- `Dockerfile` (1:1)
+
+- `env` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file