---
title: Alternatives
product: ccpem-pipeliner
doc_type: concept
version: main
source: git2docs (code-derived, validation-filtered)
canonical: https://git2docs.com/wabam/docs/ccpem-pipeliner/ccpem-pipeliner/alternatives
---

# Alternatives

_How pipeliner compares with shell scripts, the RELION GUI and general-purpose workflow engines_

## Overview

This page explains how CCPEM-Pipeliner relates to the alternatives you might already be using: shell scripts, the RELION GUI, and general-purpose workflow engines such as Nextflow or Snakemake. Understanding where pipeliner sits relative to these tools helps you decide when to use it directly, when to layer it on top of an existing system, and what trade-offs to expect.

## Examples

### Check whether an existing RELION project can be opened by pipeliner

If you have a project created by the RELION GUI, navigate into the project directory and verify that pipeliner can read the pipeline file:

```bash
cd /path/to/my_relion_project
python -c "
from pipeliner.project_graph import ProjectGraph
with ProjectGraph(read_only=True) as pg:
    print(f'Jobs in pipeline: {len(pg.process_list)}')
"
```

### Open an existing RELION project with the Python API

Pipeliner detects `default_pipeline.star` automatically when you instantiate `PipelinerProject` in the project directory. No `--new_project` flag or extra setup is needed:

```python
import os
from pipeliner.api.manage_project import PipelinerProject

os.chdir("/path/to/my_relion_project")
proj = PipelinerProject()  # opens the existing project; does not create a new one
```

### Schedule and run a job from a script (replacing a shell-script step)

The following replaces a shell-script call to `relion_run_motioncorr` with a pipeliner-managed job that writes provenance, tracks status, and produces GUI-compatible output:

```python
import os
from pipeliner.api.manage_project import PipelinerProject
from pipeliner.api.api_utils import job_default_parameters_dict

os.chdir("/path/to/project")
proj = PipelinerProject(make_new_project=True)

# Get default parameters for the motion-correction job type
params = job_default_parameters_dict("relion.motioncorr.own")

# Set required input and key parameters (keys, not labels)
params["input_star_mics"] = "Import/job001/movies.star"
params["fn_gain_ref"] = "gain.mrc"
params["patch_x"] = "5"
params["patch_y"] = "5"

# Run the job; pipeliner assigns a sequential job number and writes sentinel files
job = proj.run_job(params, run_in_foreground=True)
print(job.output_dir)  # e.g. MotionCorr/job002/
```

### Call pipeliner from an outer workflow script (facility automation pattern)

An outer shell script (or Nextflow process) can invoke pipeliner headlessly and poll for completion by checking the sentinel file:

```bash
# Generate a default run.job file for import
pipeliner --default_runjob relion.import.movies
# (edit relion_import_movies_run.job as needed, then run it)
pipeliner --run_job relion_import_movies_run.job

# Poll for completion (the outer script decides how long to wait)
while [ ! -f Import/job001/PIPELINER_JOB_EXIT_SUCCESS ]; do
    sleep 10
done
echo "Import job succeeded"
```

### Generate a reproducibility document after processing

After completing a dataset, produce a dated `.rst` tutorial that captures every parameter choice up to the final refinement job:

```bash
pipeliner.make_project_tutorial --job Refine3D/job007/
```

## Related concepts

- **Project** — Understand the project directory layout, the `default_pipeline.star` graph file, and the `.CCPEM_pipeliner_project` marker that pipeliner writes when it opens or creates a project.
- **Job** — How individual processing steps are represented, parameterised, and tracked with status sentinel files.
- **Pipeline** — The directed graph of jobs and data nodes that makes reproducible, end-to-end processing possible.
- **Job plugin entry-point (`ccpem_pipeliner.jobs`)** — How to extend pipeliner with custom job types that appear alongside built-in jobs, without modifying the core package.
- **Doppio GUI** — The CCP-EM graphical interface where you can open, inspect, and continue any pipeliner project without the command line.
- **Queue submission** — How pipeliner integrates with HPC cluster schedulers (SLURM, SGE) so that the same job definitions work both locally and on a cluster, controlled per-job via the `do_queue` option.
