From 1c43d0daa73bdc84715132cc9595f78ffd636373 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Wed, 24 Apr 2019 12:42:13 -0700
Subject: [PATCH 01/24] ref(cli,workflows): Allow multiple standard spaces

This is a large refactor using two major inter-related features:
  - Uses poldracklab/smriprep#72 and its continuation within
    poldracklab/smriprep#75 to permit the specification of several
    spatial normalization targets (close #1558).
  - Uses the refactor of Reports generation of
    poldracklab/niworkflows#344, which enables rendering reports with
    several normalization spaces. Correspondingly, report generation
    code and config files have been removed.

Correspondingly, the new interface for ``--output-spaces`` is also
incorporated (close #1588).
---
 docs/usage.rst                          | 101 +++++
 docs/workflows.rst                      |   6 +-
 fmriprep/__about__.py                   |   4 +-
 fmriprep/cli/run.py                     | 499 ++++++++-------------
 fmriprep/interfaces/reports.py          |  45 +-
 fmriprep/utils/bids.py                  |  88 ++++
 fmriprep/utils/sentry.py                | 209 +++++++++
 fmriprep/viz/__init__.py                |   8 -
 fmriprep/viz/config.json                | 151 -------
 fmriprep/viz/report.tpl                 | 186 --------
 fmriprep/viz/reports.py                 | 366 ----------------
 fmriprep/workflows/base.py              | 427 ++++++++++--------
 fmriprep/workflows/bold/__init__.py     |   4 +-
 fmriprep/workflows/bold/base.py         | 547 ++++++++----------------
 fmriprep/workflows/bold/confounds.py    |  96 ++---
 fmriprep/workflows/bold/outputs.py      | 226 ++++++++++
 fmriprep/workflows/bold/registration.py |   6 +-
 fmriprep/workflows/bold/resampling.py   | 292 +++++++------
 fmriprep/workflows/fieldmap/__init__.py |   8 +
 fmriprep/workflows/fieldmap/base.py     |  28 +-
 fmriprep/workflows/fieldmap/fmap.py     |   2 +-
 fmriprep/workflows/fieldmap/phdiff.py   |   3 +-
 fmriprep/workflows/fieldmap/syn.py      |   8 +-
 fmriprep/workflows/fieldmap/unwarp.py   |  12 +-
 requirements.txt                        |   4 +-
 setup.py                                |   2 -
 26 files changed, 1525 insertions(+), 1803 deletions(-)
 create mode 100644 fmriprep/utils/sentry.py
 delete mode 100644 fmriprep/viz/__init__.py
 delete mode 100644 fmriprep/viz/config.json
 delete mode 100644 fmriprep/viz/report.tpl
 delete mode 100644 fmriprep/viz/reports.py
 create mode 100644 fmriprep/workflows/bold/outputs.py

diff --git a/docs/usage.rst b/docs/usage.rst
index 30fadd453..8dd0f9563 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -37,6 +37,107 @@ Command-Line Arguments
    :nodefault:
    :nodefaultconst:
 
+Defining standard and nonstandard spaces where data will be resampled
+=====================================================================
+
+The command line interface of fMRIPrep allows resampling the preprocessed data
+onto other output spaces.
+That is achieved using the ``--output-spaces`` argument, where standard and
+nonstandard spaces can be inserted.
+
+Standard spaces
+---------------
+
+When using fMRIPrep in a workflow that will investigate effects that span across
+analytical groupings, neuroimagers typically resample their data on to a standard,
+stereotactic coordinate system.
+The most extended standard space for fMRI analyses is generally referred to MNI.
+For instance, to instruct fMRIPrep to use the MNI template brain distributed with
+FSL as coordinate reference the option will read as follows: ``--output-spaces MNI152NLin6Asym``.
+By default, fMRIPrep uses ``MNI152NLin2009cAsym`` as spatial-standardization reference.
+Valid template identifiers (``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, etc.) come from
+the `TemplateFlow project <https://github.com/templateflow/templateflow>`__.
+
+Therefore, fMRIPrep will run nonlinear registration processes against the template
+T1w image corresponding to all the standard spaces supplied with the argument
+``--output-spaces``.
+By default, fMRIPrep will resample the preprocessed data on those spaces (labeling the
+corresponding outputs with the `space-<template-identifier>` BIDS entity) but keeping
+the original resolution of the BOLD data to produce smaller files, more consistent with
+the original data gridding.
+However, many users will be interested in utilizing a coarse gridding (typically 2mm isotropic)
+of the target template.
+Such a behavior can be achieved applying modifiers to the template identifier, separated by
+a ``:`` character. 
+For instance, ``--output-spaces MNI152NLin6Asym:res-2 MNI152NLin2009cAsym`` will generate
+preprocessed BOLD 4D files on two standard spaces (``MNI152NLin6Asym``, 
+and ``MNI152NLin2009cAsym``) with the template's 2mm isotropic resolution for
+the data on ``MNI152NLin6Asym`` space and the original BOLD resolution
+(say, e.g., 2x2x2.5 [mm]) for the case of ``MNI152NLin2009cAsym``.
+
+Other possible modifiers are, for instance, the ``cohort`` selector.
+Although currently there is no template in TemplateFlow with several cohorts,
+very soon we will integrate pediatric templates, for which ``cohort`` will
+function to select the appropriate age range.
+Therefore, in upcoming versions of fMRIPrep, it will be possible to run it with
+``--output-spaces MNIPediatricAsym:res-2:cohort-2`` where ``cohort-2`` would select
+the template instance for the, say, 24-48 months old range.
+
+When specifying surface spaces (e.g. ``fsaverage``), the legacy identifiers from
+FreeSurfer will be supported (e.g. ``fsaverage5``) although the use of the density
+modifier would be preferred (i.e. ``fsaverage:den-10k`` for ``fsaverage5``).
+
+Custom standard spaces
+----------------------
+
+Although the functionality is not available yet, the interface of the
+``--output-spaces`` permits providing paths to custom templates that
+follow TemplateFlow's naming conventions
+(e.g. ``/path/to/custom/templates/tpl-MyCustom:res-2``).
+Following the example, at least the following files
+must be found under under ``/path/to/custom/templates/tpl-MyCustom``: ::
+
+  tpl-MyCustom/
+      template_description.json
+      tpl-MyCustom_res-1_T1w.nii.gz
+      tpl-MyCustom_res-1_desc-brain_mask.nii.gz
+      tpl-MyCustom_res-2_T1w.nii.gz
+      tpl-MyCustom_res-2_desc-brain_mask.nii.gz
+
+Although a more comprehensive coverage of standard files would be advised.
+
+Nonstandard spaces
+------------------
+
+Additionally, ``--output-spaces`` accepts identifiers of spatial references
+that do not generate *standardized* coordinate spaces:
+
+  * ``T1w`` or ``anat``: data are resampled into the individual's anatomical
+    reference generated with the T1w and T2w images available within the 
+    BIDS structure.
+  * ``fsnative``: similarly to the ``anat`` space for volumetric references,
+    including the ``fsnative`` space will instruct fMRIPrep to sample the
+    original BOLD data onto FreeSurfer's reconstructed surfaces for this
+    individual.
+  * **Additional nonstandard spaces** that will be supported in the future are
+    ``run``, ``func``, and ``sbref``.
+
+Modifiers are not allowed when providing nonstandard spaces.
+
+Preprocessing blocks depending on standard templates
+----------------------------------------------------
+
+Some modules of the pipeline (e.g. the ICA-AROMA denoising, the generation of
+HCP compatible *grayordinates* files, or the *fieldmap-less* distortion correction)
+perform on specific template spaces.
+When selecting those modules to be included (using any of the following flags:
+``--use-aroma``, ``--cifti-outputs``, ``--use-syn-sdc``) will modify the list of
+output spaces to include the space identifiers they require, should the
+identifier not be found within the ``--output-spaces`` list already.
+In other words, running fMRIPrep with ``--output-spaces MNI152NLin6Asym:res-2
+--use-syn-sdc`` will expand the list of output spaces to be
+``MNI152NLin6Asym:res-2 MNI152NLin2009cAsym``.
+
 
 The docker wrapper CLI
 ======================
diff --git a/docs/workflows.rst b/docs/workflows.rst
index 358b558ff..ff015539c 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -472,14 +472,14 @@ Excessive deviation will result in rejecting the BBR refinement and accepting th
 
 EPI to MNI transformation
 ~~~~~~~~~~~~~~~~~~~~~~~~~
-:mod:`fmriprep.workflows.bold.resampling.init_bold_mni_trans_wf`
+:mod:`fmriprep.workflows.bold.resampling.init_bold_std_trans_wf`
 
 .. workflow::
     :graph2use: colored
     :simple_form: yes
 
-    from fmriprep.workflows.bold import init_bold_mni_trans_wf
-    wf = init_bold_mni_trans_wf(
+    from fmriprep.workflows.bold import init_bold_std_trans_wf
+    wf = init_bold_std_trans_wf(
         template='MNI152NLin2009cAsym',
 		freesurfer=True,
         mem_gb=1,
diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index fd3d2f9f7..f0a5d46c7 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -105,8 +105,8 @@
 
 LINKS_REQUIRES = [
     'git+https://github.com/poldracklab/niworkflows.git@'
-    'b7d111c8fd36a099c74be5e7671677eedb175533#egg=niworkflows',
-    'git+https://github.com/poldracklab/smriprep.git@'
+    'unstable#egg=niworkflows',
+    'git+https://github.com/poldracklab/unstable.git@'
     '423bcc43ab7300177eb3b98da62817b2cad8eb87#egg=smriprep-0.1.0',
 ]
 
diff --git a/fmriprep/cli/run.py b/fmriprep/cli/run.py
index ec0cdf2c3..ac13ebfd8 100755
--- a/fmriprep/cli/run.py
+++ b/fmriprep/cli/run.py
@@ -11,19 +11,12 @@
 import logging
 import sys
 import gc
-import re
 import uuid
-import json
-import tempfile
-import psutil
-import hashlib
 import warnings
-import subprocess
 from argparse import ArgumentParser
 from argparse import RawTextHelpFormatter
 from multiprocessing import cpu_count
 from time import strftime
-from glob import glob
 
 logging.addLevelName(25, 'IMPORTANT')  # Add a new level between INFO and WARNING
 logging.addLevelName(15, 'VERBOSE')  # Add a new level between INFO and DEBUG
@@ -45,7 +38,10 @@ def check_deps(workflow):
 
 def get_parser():
     """Build parser object"""
+    from smriprep.cli.utils import ParseTemplates
+    from templateflow.api import templates
     from ..__about__ import __version__
+    from ..workflows.bold.resampling import NONSTANDARD_REFERENCES
 
     verstr = 'fmriprep v{}'.format(__version__)
 
@@ -131,43 +127,47 @@ def get_parser():
              'T2*-driven coregistration. When multi-echo data is provided and this '
              'option is not enabled, standard EPI-T1 coregistration is performed '
              'using the middle echo.')
-    g_conf.add_argument('--bold2t1w-dof', action='store', default=6, choices=[6, 9, 12], type=int,
-                        help='Degrees of freedom when registering BOLD to T1w images. '
-                             '6 degrees (rotation and translation) are used by default.')
     g_conf.add_argument(
-        '--output-space', required=False, action='store',
+        '--output-spaces', nargs='+', action=ParseTemplates,
+        help="""\
+Paths or keywords prescribing standard spaces to which normalize the input T1w image \
+and nonstandard spaces in which BOLD runs will be resampled (valid keywords are: \
+%s and paths poing to templates) with modifiers (optional parameters).
+Output spaces may be templates with modifiers or dataset-specific references. \
+Templates take the form ``<TEMPLATE>[:res-<resolution>][:cohort-<label>][...]``,  \
+with optional, colon-separated parameters, while dataset-specific references imply \
+a specific orientation and sampling grid.\
+""" % ', '.join('"%s"' % s for s in templates() + NONSTANDARD_REFERENCES))
+
+    g_conf.add_argument(
+        '--output-space', required=False, action='store', type=str, nargs='+',
         choices=['T1w', 'template', 'fsnative', 'fsaverage', 'fsaverage6', 'fsaverage5'],
-        nargs='+', default=['template', 'fsaverage5'],
-        help='volume and surface spaces to resample functional series into\n'
-             ' - T1w: subject anatomical volume\n'
-             ' - template: normalization target specified by --template\n'
-             ' - fsnative: individual subject surface\n'
-             ' - fsaverage*: FreeSurfer average meshes\n'
-             'this argument can be single value or a space delimited list,\n'
-             'for example: --output-space T1w fsnative'
+        help='DEPRECATED: please use ``--output-spaces`` instead.'
     )
     g_conf.add_argument(
-        '--force-bbr', action='store_true', dest='use_bbr', default=None,
-        help='Always use boundary-based registration (no goodness-of-fit checks)')
-    g_conf.add_argument(
-        '--force-no-bbr', action='store_false', dest='use_bbr', default=None,
-        help='Do not use boundary-based registration (no goodness-of-fit checks)')
-    g_conf.add_argument(
-        '--template', required=False, action='store',
-        choices=['MNI152NLin2009cAsym'], default='MNI152NLin2009cAsym',
-        help='volume template space (default: MNI152NLin2009cAsym)')
+        '--template', required=False, action='store', type=str,
+        choices=['MNI152NLin2009cAsym'],
+        help='volume template space (default: MNI152NLin2009cAsym). '
+             'DEPRECATED: please use ``--output-spaces`` instead.')
     g_conf.add_argument(
-        '--output-grid-reference', required=False, action='store',
-        help='Deprecated after FMRIPREP 1.0.8. Please use --template-resampling-grid instead.')
-    g_conf.add_argument(
-        '--template-resampling-grid', required=False, action='store', default='native',
+        '--template-resampling-grid', required=False, action='store',
         help='Keyword ("native", "1mm", or "2mm") or path to an existing file. '
              'Allows to define a reference grid for the resampling of BOLD images in template '
              'space. Keyword "native" will use the original BOLD grid as reference. '
              'Keywords "1mm" and "2mm" will use the corresponding isotropic template '
              'resolutions. If a path is given, the grid of that image will be used. '
              'It determines the field of view and resolution of the output images, '
-             'but is not used in normalization.')
+             'but is not used in normalization. '
+             'DEPRECATED: please use ``--output-spaces`` instead.')
+    g_conf.add_argument('--bold2t1w-dof', action='store', default=6, choices=[6, 9, 12], type=int,
+                        help='Degrees of freedom when registering BOLD to T1w images. '
+                             '6 degrees (rotation and translation) are used by default.')
+    g_conf.add_argument(
+        '--force-bbr', action='store_true', dest='use_bbr', default=None,
+        help='Always use boundary-based registration (no goodness-of-fit checks)')
+    g_conf.add_argument(
+        '--force-no-bbr', action='store_false', dest='use_bbr', default=None,
+        help='Do not use boundary-based registration (no goodness-of-fit checks)')
     g_conf.add_argument(
         '--medial-surface-nan', required=False, action='store_true', default=False,
         help='Replace medial wall values with NaNs on functional GIFTI files. Only '
@@ -209,7 +209,7 @@ def get_parser():
     # FreeSurfer options
     g_fs = parser.add_argument_group('Specific options for FreeSurfer preprocessing')
     g_fs.add_argument(
-        '--fs-license-file', metavar='PATH', type=os.path.abspath,
+        '--fs-license-file', type=Path,
         help='Path to FreeSurfer license key file. Get it (for free) by registering'
              ' at https://surfer.nmr.mgh.harvard.edu/registration.html')
 
@@ -260,8 +260,7 @@ def main():
     """Entry point"""
     from nipype import logging as nlogging
     from multiprocessing import set_start_method, Process, Manager
-    from ..viz.reports import generate_reports
-    from ..utils.bids import write_derivative_description
+    from ..utils.bids import write_derivative_description, validate_input_dir
     set_start_method('forkserver')
 
     warnings.showwarning = _warn_redirect
@@ -281,100 +280,30 @@ def main():
     sentry_sdk = None
     if not opts.notrack:
         import sentry_sdk
-        from ..__about__ import __version__
-        environment = "prod"
-        release = __version__
-        if not __version__:
-            environment = "dev"
-            release = "dev"
-        elif bool(int(os.getenv('FMRIPREP_DEV', 0))) or ('+' in __version__):
-            environment = "dev"
-
-        def before_send(event, hints):
-            # Filtering log messages about crashed nodes
-            if 'logentry' in event and 'message' in event['logentry']:
-                msg = event['logentry']['message']
-                if msg.startswith("could not run node:"):
-                    return None
-                elif msg.startswith("Saving crash info to "):
-                    return None
-                elif re.match("Node .+ failed to run on host .+", msg):
-                    return None
-
-            if 'breadcrumbs' in event and isinstance(event['breadcrumbs'], list):
-                fingerprints_to_propagate = ['no-disk-space', 'memory-error', 'permission-denied',
-                                             'keyboard-interrupt']
-                for bc in event['breadcrumbs']:
-                    msg = bc.get('message', 'empty-msg')
-                    if msg in fingerprints_to_propagate:
-                        event['fingerprint'] = [msg]
-                        break
-
-            return event
-
-        sentry_sdk.init("https://d5a16b0c38d84d1584dfc93b9fb1ade6@sentry.io/1137693",
-                        release=release,
-                        environment=environment,
-                        before_send=before_send)
-        with sentry_sdk.configure_scope() as scope:
-            scope.set_tag('exec_env', exec_env)
-
-            if exec_env == 'fmriprep-docker':
-                scope.set_tag('docker_version', os.getenv('DOCKER_VERSION_8395080871'))
-
-            dset_desc_path = opts.bids_dir / 'dataset_description.json'
-            if dset_desc_path.exists():
-                desc_content = dset_desc_path.read_bytes()
-                scope.set_tag('dset_desc_sha256', hashlib.sha256(desc_content).hexdigest())
-
-            free_mem_at_start = round(psutil.virtual_memory().free / 1024**3, 1)
-            scope.set_tag('free_mem_at_start', free_mem_at_start)
-            scope.set_tag('cpu_count', cpu_count())
-
-            # Memory policy may have a large effect on types of errors experienced
-            overcommit_memory = Path('/proc/sys/vm/overcommit_memory')
-            if overcommit_memory.exists():
-                policy = {'0': 'heuristic',
-                          '1': 'always',
-                          '2': 'never'}.get(overcommit_memory.read_text().strip(), 'unknown')
-                scope.set_tag('overcommit_memory', policy)
-                if policy == 'never':
-                    overcommit_kbytes = Path('/proc/sys/vm/overcommit_memory')
-                    kb = overcommit_kbytes.read_text().strip()
-                    if kb != '0':
-                        limit = '{}kB'.format(kb)
-                    else:
-                        overcommit_ratio = Path('/proc/sys/vm/overcommit_ratio')
-                        limit = '{}%'.format(overcommit_ratio.read_text().strip())
-                    scope.set_tag('overcommit_limit', limit)
-                else:
-                    scope.set_tag('overcommit_limit', 'n/a')
-            else:
-                scope.set_tag('overcommit_memory', 'n/a')
-                scope.set_tag('overcommit_limit', 'n/a')
-
-            for k, v in vars(opts).items():
-                scope.set_tag(k, v)
+        from ..utils.sentry import sentry_setup
+        sentry_setup(opts, exec_env)
+
+    if opts.debug:
+        print('WARNING: Option --debug is deprecated and has no effect',
+              file=sys.stderr)
 
     # Validate inputs
     if not opts.skip_bids_validation:
         print("Making sure the input data is BIDS compliant (warnings can be ignored in most "
               "cases).")
-        validate_input_dir(exec_env, str(opts.bids_dir), opts.participant_label)
+        validate_input_dir(exec_env, opts.bids_dir, opts.participant_label)
 
     # FreeSurfer license
     default_license = str(Path(os.getenv('FREESURFER_HOME')) / 'license.txt')
     # Precedence: --fs-license-file, $FS_LICENSE, default_license
-    license_file = opts.fs_license_file or os.getenv('FS_LICENSE', default_license)
-    if not os.path.exists(license_file):
-        raise RuntimeError(
-            'ERROR: a valid license file is required for FreeSurfer to run. '
-            'FMRIPREP looked for an existing license file at several paths, in this '
-            'order: 1) command line argument ``--fs-license-file``; 2) ``$FS_LICENSE`` '
-            'environment variable; and 3) the ``$FREESURFER_HOME/license.txt`` path. '
-            'Get it (for free) by registering at https://'
-            'surfer.nmr.mgh.harvard.edu/registration.html')
-    os.environ['FS_LICENSE'] = license_file
+    license_file = opts.fs_license_file or Path(os.getenv('FS_LICENSE', default_license))
+    if not license_file.exists():
+        raise RuntimeError("""\
+ERROR: a valid license file is required for FreeSurfer to run. fMRIPrep looked for an existing \
+license file at several paths, in this order: 1) command line argument ``--fs-license-file``; \
+2) ``$FS_LICENSE`` environment variable; and 3) the ``$FREESURFER_HOME/license.txt`` path. Get it \
+(for free) by registering at https://surfer.nmr.mgh.harvard.edu/registration.html""")
+    os.environ['FS_LICENSE'] = str(license_file.resolve())
 
     # Retrieve logging level
     log_level = int(max(25 - 5 * opts.verbose_count, logging.DEBUG))
@@ -384,8 +313,6 @@ def before_send(event, hints):
     nlogging.getLogger('nipype.interface').setLevel(log_level)
     nlogging.getLogger('nipype.utils').setLevel(log_level)
 
-    errno = 0
-
     # Call build_workflow(opts, retval)
     with Manager() as mgr:
         retval = mgr.dict()
@@ -396,7 +323,7 @@ def before_send(event, hints):
         retcode = p.exitcode or retval.get('return_code', 0)
 
         bids_dir = retval.get('bids_dir')
-        output_dir = retval.get('output_dir')
+        output_dir = Path(retval.get('output_dir'))
         work_dir = retval.get('work_dir')
         plugin_settings = retval.get('plugin_settings', None)
         subject_list = retval.get('subject_list', None)
@@ -419,7 +346,7 @@ def before_send(event, hints):
     # Check workflow for missing commands
     missing = check_deps(fmriprep_wf)
     if missing:
-        print("Cannot run fMRIPrep. Missing dependencies:")
+        print("Cannot run fMRIPrep. Missing dependencies:", file=sys.stderr)
         for iface, cmd in missing:
             print("\t{} (Interface: {})".format(cmd, iface))
         sys.exit(2)
@@ -428,131 +355,51 @@ def before_send(event, hints):
 
     # Sentry tracking
     if not opts.notrack:
-        with sentry_sdk.configure_scope() as scope:
-            if run_uuid:
-                scope.set_tag('run_uuid', run_uuid)
-            if subject_list:
-                scope.set_tag('npart', len(subject_list))
-        sentry_sdk.add_breadcrumb(message='fMRIPrep started', level='info')
-        sentry_sdk.capture_message('fMRIPrep started', level='info')
+        from ..utils.sentry import start_ping
+        start_ping(run_uuid, len(subject_list))
 
+    errno = 1  # Default is error exit unless otherwise set
     try:
         fmriprep_wf.run(**plugin_settings)
-    except RuntimeError as e:
-        errno = 1
-        if "Workflow did not execute cleanly" not in str(e):
-            sentry_sdk.capture_exception(e)
-            raise
+    except Exception as e:
+        if not opts.notrack:
+            from ..utils.sentry import process_crashfile
+            crashfolders = [output_dir / 'fmriprep' / 'sub-{}'.format(s) / 'log' / run_uuid
+                            for s in subject_list]
+            for crashfolder in crashfolders:
+                for crashfile in crashfolder.glob('crash*.*'):
+                    process_crashfile(crashfile)
+
+            if "Workflow did not execute cleanly" not in str(e):
+                sentry_sdk.capture_exception(e)
+        logger.error('Error: %s', e)
+        raise
     else:
         if opts.run_reconall:
             from templateflow import api
             from niworkflows.utils.misc import _copy_any
             dseg_tsv = str(api.get('fsaverage', suffix='dseg', extensions=['.tsv']))
             _copy_any(dseg_tsv,
-                      str(Path(output_dir) / 'fmriprep' / 'desc-aseg_dseg.tsv'))
+                      str(output_dir / 'fmriprep' / 'desc-aseg_dseg.tsv'))
             _copy_any(dseg_tsv,
-                      str(Path(output_dir) / 'fmriprep' / 'desc-aparcaseg_dseg.tsv'))
+                      str(output_dir / 'fmriprep' / 'desc-aparcaseg_dseg.tsv'))
+        errno = 0
         logger.log(25, 'fMRIPrep finished without errors')
+        if not opts.notrack:
+            sentry_sdk.capture_message('fMRIPrep finished without errors',
+                                       level='info')
     finally:
+        from niworkflows.reports import generate_reports
         # Generate reports phase
-        errno += generate_reports(subject_list, output_dir, work_dir, run_uuid,
-                                  sentry_sdk=sentry_sdk)
-        write_derivative_description(bids_dir, str(Path(output_dir) / 'fmriprep'))
-
-    if not opts.notrack and errno == 0:
-        sentry_sdk.capture_message('fMRIPrep finished without errors', level='info')
-    sys.exit(int(errno > 0))
-
-
-def validate_input_dir(exec_env, bids_dir, participant_label):
-    # Ignore issues and warnings that should not influence FMRIPREP
-    validator_config_dict = {
-        "ignore": [
-            "EVENTS_COLUMN_ONSET",
-            "EVENTS_COLUMN_DURATION",
-            "TSV_EQUAL_ROWS",
-            "TSV_EMPTY_CELL",
-            "TSV_IMPROPER_NA",
-            "VOLUME_COUNT_MISMATCH",
-            "BVAL_MULTIPLE_ROWS",
-            "BVEC_NUMBER_ROWS",
-            "DWI_MISSING_BVAL",
-            "INCONSISTENT_SUBJECTS",
-            "INCONSISTENT_PARAMETERS",
-            "BVEC_ROW_LENGTH",
-            "B_FILE",
-            "PARTICIPANT_ID_COLUMN",
-            "PARTICIPANT_ID_MISMATCH",
-            "TASK_NAME_MUST_DEFINE",
-            "PHENOTYPE_SUBJECTS_MISSING",
-            "STIMULUS_FILE_MISSING",
-            "DWI_MISSING_BVEC",
-            "EVENTS_TSV_MISSING",
-            "TSV_IMPROPER_NA",
-            "ACQTIME_FMT",
-            "Participants age 89 or higher",
-            "DATASET_DESCRIPTION_JSON_MISSING",
-            "FILENAME_COLUMN",
-            "WRONG_NEW_LINE",
-            "MISSING_TSV_COLUMN_CHANNELS",
-            "MISSING_TSV_COLUMN_IEEG_CHANNELS",
-            "MISSING_TSV_COLUMN_IEEG_ELECTRODES",
-            "UNUSED_STIMULUS",
-            "CHANNELS_COLUMN_SFREQ",
-            "CHANNELS_COLUMN_LOWCUT",
-            "CHANNELS_COLUMN_HIGHCUT",
-            "CHANNELS_COLUMN_NOTCH",
-            "CUSTOM_COLUMN_WITHOUT_DESCRIPTION",
-            "ACQTIME_FMT",
-            "SUSPICIOUSLY_LONG_EVENT_DESIGN",
-            "SUSPICIOUSLY_SHORT_EVENT_DESIGN",
-            "MALFORMED_BVEC",
-            "MALFORMED_BVAL",
-            "MISSING_TSV_COLUMN_EEG_ELECTRODES",
-            "MISSING_SESSION"
-        ],
-        "error": ["NO_T1W"],
-        "ignoredFiles": ['/dataset_description.json', '/participants.tsv']
-    }
-    # Limit validation only to data from requested participants
-    if participant_label:
-        all_subs = set([os.path.basename(i)[4:] for i in glob(os.path.join(bids_dir,
-                                                                           "sub-*"))])
-        selected_subs = []
-        for selected_sub in participant_label:
-            if selected_sub.startswith("sub-"):
-                selected_subs.append(selected_sub[4:])
-            else:
-                selected_subs.append(selected_sub)
-        selected_subs = set(selected_subs)
-        bad_labels = selected_subs.difference(all_subs)
-        if bad_labels:
-            error_msg = 'Data for requested participant(s) label(s) not found. Could ' \
-                        'not find data for participant(s): %s. Please verify the requested ' \
-                        'participant labels.'
-            if exec_env == 'docker':
-                error_msg += ' This error can be caused by the input data not being ' \
-                             'accessible inside the docker container. Please make sure all ' \
-                             'volumes are mounted properly (see https://docs.docker.com/' \
-                             'engine/reference/commandline/run/#mount-volume--v---read-only)'
-            if exec_env == 'singularity':
-                error_msg += ' This error can be caused by the input data not being ' \
-                             'accessible inside the singularity container. Please make sure ' \
-                             'all paths are mapped properly (see https://www.sylabs.io/' \
-                             'guides/3.0/user-guide/bind_paths_and_mounts.html)'
-            raise RuntimeError(error_msg % ','.join(bad_labels))
-
-        ignored_subs = all_subs.difference(selected_subs)
-        if ignored_subs:
-            for sub in ignored_subs:
-                validator_config_dict["ignoredFiles"].append("/sub-%s/**" % sub)
-    with tempfile.NamedTemporaryFile('w+') as temp:
-        temp.write(json.dumps(validator_config_dict))
-        temp.flush()
-        try:
-            subprocess.check_call(['bids-validator', bids_dir, '-c', temp.name])
-        except FileNotFoundError:
-            logger.error("bids-validator does not appear to be installed")
+        failed_reports = generate_reports(
+            subject_list, output_dir, work_dir, run_uuid, packagename='fmriprep')
+        write_derivative_description(bids_dir, output_dir / 'fmriprep')
+
+        if failed_reports and not opts.notrack:
+            sentry_sdk.capture_message(
+                'Report generation failed for %d subjects' % failed_reports,
+                level='error')
+        sys.exit(int((errno + failed_reports) > 0))
 
 
 def build_workflow(opts, retval):
@@ -573,10 +420,10 @@ def build_workflow(opts, retval):
     from bids import BIDSLayout
 
     from nipype import logging, config as ncfg
+    from niworkflows.reports import generate_reports
     from niworkflows.utils.bids import collect_participants
     from ..__about__ import __version__
     from ..workflows.base import init_fmriprep_wf
-    from ..viz.reports import generate_reports
 
     logger = logging.getLogger('nipype.workflow')
 
@@ -589,7 +436,7 @@ def build_workflow(opts, retval):
 
     bids_dir = opts.bids_dir.resolve()
     output_dir = opts.output_dir.resolve()
-    work_dir = opts.work_dir
+    work_dir = opts.work_dir.resolve()
 
     retval['return_code'] = 1
     retval['workflow'] = None
@@ -605,48 +452,7 @@ def build_workflow(opts, retval):
         retval['return_code'] = 1
         return retval
 
-    # Reduce to unique space identifiers
-    output_spaces = sorted(set(opts.output_space))
-
-    # If FS is not run, drop all fs* output spaces
-    if not opts.run_reconall:
-        output_spaces = [item for item in output_spaces if not item.startswith('fs')]
-
-    # Validity of some inputs
-    # ERROR check if use_aroma was specified, but the correct template was not
-    if opts.use_aroma and (opts.template != 'MNI152NLin2009cAsym' or
-                           'template' not in output_spaces):
-        output_spaces.append('template')
-        logger.warning(
-            'Option "--use-aroma" requires functional images to be resampled to MNI space. '
-            'The argument "template" has been automatically added to the list of output '
-            'spaces (option "--output-space").'
-        )
-
-    if opts.cifti_output:
-        if 'template' not in output_spaces:
-            output_spaces.append('template')
-            logger.warning(
-                'Option "--cifti-output" requires functional images to be resampled to MNI '
-                'space. The argument "template" has been automatically added to the list of '
-                'output spaces (option "--output-space").')
-        if not [s for s in output_spaces if s in ('fsaverage5', 'fsaverage6')]:
-            output_spaces = sorted(output_spaces + ['fsaverage5'])
-            logger.warning(
-                'Option "--cifti-output" requires functional images to be resampled to fsaverage '
-                'space. The argument "fsaverage5" has been automatically added to the list of '
-                'output spaces (option "--output-space").')
-
-    # Check output_space
-    if 'template' not in output_spaces and (opts.use_syn_sdc or opts.force_syn):
-        msg = ['SyN SDC correction requires T1 to MNI registration, but '
-               '"template" is not specified in "--output-space" arguments.',
-               'Option --use-syn will be cowardly dismissed.']
-        if opts.force_syn:
-            output_spaces.append('template')
-            msg[1] = (' Since --force-syn has been requested, "template" has been added to'
-                      ' the "--output-space" list.')
-        logger.warning(' '.join(msg))
+    output_spaces = parse_spaces(opts)
 
     # Set up some instrumental utilities
     run_uuid = '%s_%s' % (strftime('%Y%m%d-%H%M%S'), uuid.uuid4())
@@ -734,7 +540,8 @@ def build_workflow(opts, retval):
             run_uuid = opts.run_uuid
             retval['run_uuid'] = run_uuid
         retval['return_code'] = generate_reports(
-            subject_list, str(output_dir), str(work_dir), run_uuid)
+            subject_list, str(output_dir), str(work_dir), run_uuid,
+            packagename='fmriprep')
         return retval
 
     # Build main workflow
@@ -745,48 +552,37 @@ def build_workflow(opts, retval):
         uuid=run_uuid)
     )
 
-    template_out_grid = opts.template_resampling_grid
-    if opts.output_grid_reference is not None:
-        logger.warning(
-            'Option --output-grid-reference is deprecated, please use '
-            '--template-resampling-grid')
-        template_out_grid = template_out_grid or opts.output_grid_reference
-    if opts.debug:
-        logger.warning('Option --debug is deprecated and has no effect')
-
     retval['workflow'] = init_fmriprep_wf(
-        layout=layout,
-        subject_list=subject_list,
-        task_id=opts.task_id,
+        anat_only=opts.anat_only,
+        aroma_melodic_dim=opts.aroma_melodic_dimensionality,
+        bold2t1w_dof=opts.bold2t1w_dof,
+        cifti_output=opts.cifti_output,
+        debug=opts.sloppy,
         echo_idx=opts.echo_idx,
-        run_uuid=run_uuid,
+        err_on_aroma_warn=opts.error_on_aroma_warnings,
+        fmap_bspline=opts.fmap_bspline,
+        fmap_demean=opts.fmap_no_demean,
+        force_syn=opts.force_syn,
+        freesurfer=opts.run_reconall,
+        hires=opts.hires,
         ignore=opts.ignore,
-        debug=opts.sloppy,
-        low_mem=opts.low_mem,
-        anat_only=opts.anat_only,
+        layout=layout,
         longitudinal=opts.longitudinal,
-        t2s_coreg=opts.t2s_coreg,
+        low_mem=opts.low_mem,
+        medial_surface_nan=opts.medial_surface_nan,
         omp_nthreads=omp_nthreads,
-        skull_strip_template=opts.skull_strip_template,
-        skull_strip_fixed_seed=opts.skull_strip_fixed_seed,
-        work_dir=str(work_dir),
         output_dir=str(output_dir),
-        freesurfer=opts.run_reconall,
         output_spaces=output_spaces,
-        template=opts.template,
-        medial_surface_nan=opts.medial_surface_nan,
-        cifti_output=opts.cifti_output,
-        template_out_grid=template_out_grid,
-        hires=opts.hires,
+        run_uuid=run_uuid,
+        skull_strip_fixed_seed=opts.skull_strip_fixed_seed,
+        skull_strip_template=opts.skull_strip_template,
+        subject_list=subject_list,
+        t2s_coreg=opts.t2s_coreg,
+        task_id=opts.task_id,
+        use_aroma=opts.use_aroma,
         use_bbr=opts.use_bbr,
-        bold2t1w_dof=opts.bold2t1w_dof,
-        fmap_bspline=opts.fmap_bspline,
-        fmap_demean=opts.fmap_no_demean,
         use_syn=opts.use_syn_sdc,
-        force_syn=opts.force_syn,
-        use_aroma=opts.use_aroma,
-        aroma_melodic_dim=opts.aroma_melodic_dimensionality,
-        err_on_aroma_warn=opts.error_on_aroma_warnings,
+        work_dir=str(work_dir),
     )
     retval['return_code'] = 0
 
@@ -839,6 +635,79 @@ def build_workflow(opts, retval):
     return retval
 
 
+def parse_spaces(opts):
+    """Ensures the spaces are correctly parsed"""
+    from sys import stderr
+    from collections import OrderedDict
+    from templateflow.api import templates as get_templates
+    # Set the default template to 'MNI152NLin2009c'
+    output_spaces = opts.output_spaces or OrderedDict([('MNI152NLin2009cAsym', {})])
+
+    if opts.template:
+        print("""\
+The ``--template`` option has been deprecated in version 1.4.0. Your selected template \
+"%s" will be inserted at the front of the ``--output-spaces`` argument list. Please update \
+your scripts to use ``--output-spaces``.""" % opts.template, file=stderr)
+        deprecated_tpl_arg = [(opts.template, {})]
+        # If output_spaces is not set, just replate the default - append otherwise
+        if opts.output_spaces is not None:
+            deprecated_tpl_arg += list(output_spaces.items())
+        output_spaces = OrderedDict(deprecated_tpl_arg)
+
+    if opts.output_space:
+        print("""\
+The ``--output_space`` option has been deprecated in version 1.4.0. Your selection of spaces \
+"%s" will be inserted at the front of the ``--output-spaces`` argument list. Please update \
+your scripts to use ``--output-spaces``.""" % ', '.join(opts.output_space), file=stderr)
+        missing = set(opts.output_space)
+        if 'template' in missing:
+            missing.remove('template')
+            if not opts.template:
+                missing.add('MNI152NLin2009cAsym')
+        missing = missing - set(output_spaces.keys())
+        output_spaces.update({tpl: {} for tpl in missing})
+
+    FS_SPACES = set(['fsnative', 'fsaverage', 'fsaverage6', 'fsaverage5'])
+    if opts.run_reconall and not list(FS_SPACES.intersection(output_spaces.keys())):
+        print("""\
+Although ``--fs-no-reconall`` was not set (i.e. FreeSurfer is to be run), no FreeSurfer \
+output space (valid values are: %s) was selected. Adding default "fsaverage5" to the \
+list of output spaces.""" % ', '.join(FS_SPACES), file=stderr)
+        output_spaces['fsaverage5'] = {}
+
+    # Validity of some inputs
+    # ERROR check if use_aroma was specified, but the correct template was not
+    if opts.use_aroma and 'MNI152NLin6Asym' not in output_spaces:
+        output_spaces['MNI152Lin6Asym'] = {'res': 2}
+        print("""\
+Option "--use-aroma" requires functional images to be resampled to MNI152Lin6Asym space. \
+The argument "MNI152Lin6Asym:res-2" has been automatically added to the list of output spaces \
+(option ``--output-spaces``).""", file=stderr)
+
+    if opts.cifti_output and 'fsLR' not in output_spaces:
+        if 'MNI152NLin6Asym' not in output_spaces:
+            output_spaces['MNI152NLin6Asym'] = {'res': 2}
+            print("""Option ``--cifti-output`` requires functional images to be resampled to \
+``MNI152LinAsym`` space. Such template identifier has been automatically added to the list \
+of output spaces (option "--output-space").""", file=stderr)
+        if not [s for s in output_spaces if s in ('fsaverage5', 'fsaverage6')]:
+            output_spaces['fsaverage5'] = {}
+            print("""Option ``--cifti-output`` requires functional images to be resampled to \
+``fsaverage`` space. The argument ``fsaverage:den-10k`` (a.k.a ``fsaverage5``) has been \
+automatically added to the list of output spaces (option ``--output-space``).""", file=stderr)
+
+    if opts.template_resampling_grid is not None:
+        print("""Option ``--template-resampling-grid`` is deprecated, please specify \
+resampling grid options as modifiers to templates listed in ``--output-spaces``. \
+The configuration value will be applied to ALL output standard spaces.""")
+        if opts.template_resampling_grid != 'native':
+            for key in output_spaces.keys():
+                if key in get_templates():
+                    output_spaces[key]['res'] = opts.template_resampling_grid[0]
+
+    return output_spaces
+
+
 if __name__ == '__main__':
     raise RuntimeError("fmriprep/cli/run.py should not be run directly;\n"
                        "Please `pip install` fmriprep and use the `fmriprep` command")
diff --git a/fmriprep/interfaces/reports.py b/fmriprep/interfaces/reports.py
index 23d394138..7637d66f0 100644
--- a/fmriprep/interfaces/reports.py
+++ b/fmriprep/interfaces/reports.py
@@ -16,18 +16,19 @@
 from collections import Counter
 from nipype.interfaces.base import (
     traits, TraitedSpec, BaseInterfaceInputSpec,
-    File, Directory, InputMultiPath, Str, isdefined,
+    File, Directory, InputMultiObject, Str, isdefined,
     SimpleInterface)
 from nipype.interfaces import freesurfer as fs
 from niworkflows.utils.bids import BIDS_NAME
 
 
-SUBJECT_TEMPLATE = """\t<ul class="elem-desc">
+SUBJECT_TEMPLATE = """\
+\t<ul class="elem-desc">
 \t\t<li>Subject ID: {subject_id}</li>
 \t\t<li>Structural images: {n_t1s:d} T1-weighted {t2w}</li>
 \t\t<li>Functional series: {n_bold:d}</li>
 {tasks}
-\t\t<li>Resampling targets: {output_spaces}
+\t\t<li>Standard output spaces: {output_spaces}</li>
 \t\t<li>FreeSurfer reconstruction: {freesurfer_status}</li>
 \t</ul>
 """
@@ -45,8 +46,8 @@
 """
 
 ABOUT_TEMPLATE = """\t<ul>
-\t\t<li>FMRIPrep version: {version}</li>
-\t\t<li>FMRIPrep command: <code>{command}</code></li>
+\t\t<li>fMRIPrep version: {version}</li>
+\t\t<li>fMRIPrep command: <code>{command}</code></li>
 \t\t<li>Date preprocessed: {date}</li>
 \t</ul>
 </div>
@@ -68,17 +69,19 @@ def _run_interface(self, runtime):
         self._results['out_report'] = fname
         return runtime
 
+    def _generate_segment(self):
+        raise NotImplementedError
+
 
 class SubjectSummaryInputSpec(BaseInterfaceInputSpec):
-    t1w = InputMultiPath(File(exists=True), desc='T1w structural images')
-    t2w = InputMultiPath(File(exists=True), desc='T2w structural images')
+    t1w = InputMultiObject(File(exists=True), desc='T1w structural images')
+    t2w = InputMultiObject(File(exists=True), desc='T2w structural images')
     subjects_dir = Directory(desc='FreeSurfer subjects directory')
     subject_id = Str(desc='Subject ID')
-    bold = InputMultiPath(traits.Either(File(exists=True),
-                                        traits.List(File(exists=True))),
-                          desc='BOLD functional series')
-    output_spaces = traits.List(desc='Target spaces')
-    template = traits.Enum('MNI152NLin2009cAsym', desc='Template space')
+    bold = InputMultiObject(traits.Either(
+        File(exists=True), traits.List(File(exists=True))),
+        desc='BOLD functional series')
+    output_spaces = InputMultiObject(Str, desc='list of standard spaces')
 
 
 class SubjectSummaryOutputSpec(SummaryOutputSpec):
@@ -109,9 +112,6 @@ def _generate_segment(self):
             else:
                 freesurfer_status = 'Run by fMRIPrep'
 
-        output_spaces = [self.inputs.template if space == 'template' else space
-                         for space in self.inputs.output_spaces]
-
         t2w_seg = ''
         if self.inputs.t2w:
             t2w_seg = '(+ {:d} T2-weighted)'.format(len(self.inputs.t2w))
@@ -132,13 +132,14 @@ def _generate_segment(self):
                      for task_id, n_runs in sorted(counts.items())]
             tasks = '\n'.join([header] + lines + [footer])
 
-        return SUBJECT_TEMPLATE.format(subject_id=self.inputs.subject_id,
-                                       n_t1s=len(self.inputs.t1w),
-                                       t2w=t2w_seg,
-                                       n_bold=len(bold_series),
-                                       tasks=tasks,
-                                       output_spaces=', '.join(output_spaces),
-                                       freesurfer_status=freesurfer_status)
+        return SUBJECT_TEMPLATE.format(
+            subject_id=self.inputs.subject_id,
+            n_t1s=len(self.inputs.t1w),
+            t2w=t2w_seg,
+            n_bold=len(bold_series),
+            tasks=tasks,
+            output_spaces=', '.join(self.inputs.output_spaces),
+            freesurfer_status=freesurfer_status)
 
 
 class FunctionalSummaryInputSpec(BaseInterfaceInputSpec):
diff --git a/fmriprep/utils/bids.py b/fmriprep/utils/bids.py
index 871dcfd65..a52e032fa 100644
--- a/fmriprep/utils/bids.py
+++ b/fmriprep/utils/bids.py
@@ -8,6 +8,7 @@
 
 """
 import os
+import sys
 import json
 from pathlib import Path
 
@@ -60,5 +61,92 @@ def write_derivative_description(bids_dir, deriv_dir):
         json.dump(desc, fobj, indent=4)
 
 
+def validate_input_dir(exec_env, bids_dir, participant_label):
+    # Ignore issues and warnings that should not influence FMRIPREP
+    import tempfile
+    import subprocess
+    validator_config_dict = {
+        "ignore": [
+            "EVENTS_COLUMN_ONSET",
+            "EVENTS_COLUMN_DURATION",
+            "TSV_EQUAL_ROWS",
+            "TSV_EMPTY_CELL",
+            "TSV_IMPROPER_NA",
+            "VOLUME_COUNT_MISMATCH",
+            "BVAL_MULTIPLE_ROWS",
+            "BVEC_NUMBER_ROWS",
+            "DWI_MISSING_BVAL",
+            "INCONSISTENT_SUBJECTS",
+            "INCONSISTENT_PARAMETERS",
+            "BVEC_ROW_LENGTH",
+            "B_FILE",
+            "PARTICIPANT_ID_COLUMN",
+            "PARTICIPANT_ID_MISMATCH",
+            "TASK_NAME_MUST_DEFINE",
+            "PHENOTYPE_SUBJECTS_MISSING",
+            "STIMULUS_FILE_MISSING",
+            "DWI_MISSING_BVEC",
+            "EVENTS_TSV_MISSING",
+            "TSV_IMPROPER_NA",
+            "ACQTIME_FMT",
+            "Participants age 89 or higher",
+            "DATASET_DESCRIPTION_JSON_MISSING",
+            "FILENAME_COLUMN",
+            "WRONG_NEW_LINE",
+            "MISSING_TSV_COLUMN_CHANNELS",
+            "MISSING_TSV_COLUMN_IEEG_CHANNELS",
+            "MISSING_TSV_COLUMN_IEEG_ELECTRODES",
+            "UNUSED_STIMULUS",
+            "CHANNELS_COLUMN_SFREQ",
+            "CHANNELS_COLUMN_LOWCUT",
+            "CHANNELS_COLUMN_HIGHCUT",
+            "CHANNELS_COLUMN_NOTCH",
+            "CUSTOM_COLUMN_WITHOUT_DESCRIPTION",
+            "ACQTIME_FMT",
+            "SUSPICIOUSLY_LONG_EVENT_DESIGN",
+            "SUSPICIOUSLY_SHORT_EVENT_DESIGN",
+            "MALFORMED_BVEC",
+            "MALFORMED_BVAL",
+            "MISSING_TSV_COLUMN_EEG_ELECTRODES",
+            "MISSING_SESSION"
+        ],
+        "error": ["NO_T1W"],
+        "ignoredFiles": ['/dataset_description.json', '/participants.tsv']
+    }
+    # Limit validation only to data from requested participants
+    if participant_label:
+        all_subs = set([s.name[4:] for s in bids_dir.glob('sub-*')])
+        selected_subs = set([s[4:] if s.startswith('sub-') else s
+                             for s in participant_label])
+        bad_labels = selected_subs.difference(all_subs)
+        if bad_labels:
+            error_msg = 'Data for requested participant(s) label(s) not found. Could ' \
+                        'not find data for participant(s): %s. Please verify the requested ' \
+                        'participant labels.'
+            if exec_env == 'docker':
+                error_msg += ' This error can be caused by the input data not being ' \
+                             'accessible inside the docker container. Please make sure all ' \
+                             'volumes are mounted properly (see https://docs.docker.com/' \
+                             'engine/reference/commandline/run/#mount-volume--v---read-only)'
+            if exec_env == 'singularity':
+                error_msg += ' This error can be caused by the input data not being ' \
+                             'accessible inside the singularity container. Please make sure ' \
+                             'all paths are mapped properly (see https://www.sylabs.io/' \
+                             'guides/3.0/user-guide/bind_paths_and_mounts.html)'
+            raise RuntimeError(error_msg % ','.join(bad_labels))
+
+        ignored_subs = all_subs.difference(selected_subs)
+        if ignored_subs:
+            for sub in ignored_subs:
+                validator_config_dict["ignoredFiles"].append("/sub-%s/**" % sub)
+    with tempfile.NamedTemporaryFile('w+') as temp:
+        temp.write(json.dumps(validator_config_dict))
+        temp.flush()
+        try:
+            subprocess.check_call(['bids-validator', bids_dir, '-c', temp.name])
+        except FileNotFoundError:
+            print("bids-validator does not appear to be installed", file=sys.stderr)
+
+
 def _get_shub_version(singularity_url):
     return NotImplemented
diff --git a/fmriprep/utils/sentry.py b/fmriprep/utils/sentry.py
new file mode 100644
index 000000000..290c9702a
--- /dev/null
+++ b/fmriprep/utils/sentry.py
@@ -0,0 +1,209 @@
+
+
+import os
+from pathlib import Path
+import re
+from niworkflows.utils.misc import read_crashfile
+import sentry_sdk
+
+CHUNK_SIZE = 16384
+# Group common events with pre specified fingerprints
+KNOWN_ERRORS = {
+    'permission-denied': [
+        "PermissionError: [Errno 13] Permission denied"
+    ],
+    'memory-error': [
+        "MemoryError",
+        "Cannot allocate memory",
+        "Return code: 134",
+    ],
+    'reconall-already-running': [
+        "ERROR: it appears that recon-all is already running"
+    ],
+    'no-disk-space': [
+        "[Errno 28] No space left on device",
+        "[Errno 122] Disk quota exceeded"
+    ],
+    'segfault': [
+        "Segmentation Fault",
+        "Segfault",
+        "Return code: 139",
+    ],
+    'potential-race-condition': [
+        "[Errno 39] Directory not empty",
+        "_unfinished.json",
+    ],
+    'keyboard-interrupt': [
+        "KeyboardInterrupt",
+    ],
+}
+
+
+def start_ping(run_uuid, npart):
+    with sentry_sdk.configure_scope() as scope:
+        if run_uuid:
+            scope.set_tag('run_uuid', run_uuid)
+        scope.set_tag('npart', npart)
+    sentry_sdk.add_breadcrumb(message='fMRIPrep started', level='info')
+    sentry_sdk.capture_message('fMRIPrep started', level='info')
+
+
+def sentry_setup(opts, exec_env):
+    from os import cpu_count
+    import psutil
+    import hashlib
+    from ..__about__ import __version__
+    from ..utils.sentry import before_send
+    environment = "prod"
+    release = __version__
+    if not __version__:
+        environment = "dev"
+        release = "dev"
+    elif int(os.getenv('FMRIPREP_DEV', 0)) or ('+' in __version__):
+        environment = "dev"
+
+    sentry_sdk.init("https://d5a16b0c38d84d1584dfc93b9fb1ade6@sentry.io/1137693",
+                    release=release,
+                    environment=environment,
+                    before_send=before_send)
+    with sentry_sdk.configure_scope() as scope:
+        scope.set_tag('exec_env', exec_env)
+
+        if exec_env == 'fmriprep-docker':
+            scope.set_tag('docker_version', os.getenv('DOCKER_VERSION_8395080871'))
+
+        dset_desc_path = opts.bids_dir / 'dataset_description.json'
+        if dset_desc_path.exists():
+            desc_content = dset_desc_path.read_bytes()
+            scope.set_tag('dset_desc_sha256', hashlib.sha256(desc_content).hexdigest())
+
+        free_mem_at_start = round(psutil.virtual_memory().free / 1024**3, 1)
+        scope.set_tag('free_mem_at_start', free_mem_at_start)
+        scope.set_tag('cpu_count', cpu_count())
+
+        # Memory policy may have a large effect on types of errors experienced
+        overcommit_memory = Path('/proc/sys/vm/overcommit_memory')
+        if overcommit_memory.exists():
+            policy = {'0': 'heuristic',
+                      '1': 'always',
+                      '2': 'never'}.get(overcommit_memory.read_text().strip(), 'unknown')
+            scope.set_tag('overcommit_memory', policy)
+            if policy == 'never':
+                overcommit_kbytes = Path('/proc/sys/vm/overcommit_memory')
+                kb = overcommit_kbytes.read_text().strip()
+                if kb != '0':
+                    limit = '{}kB'.format(kb)
+                else:
+                    overcommit_ratio = Path('/proc/sys/vm/overcommit_ratio')
+                    limit = '{}%'.format(overcommit_ratio.read_text().strip())
+                scope.set_tag('overcommit_limit', limit)
+            else:
+                scope.set_tag('overcommit_limit', 'n/a')
+        else:
+            scope.set_tag('overcommit_memory', 'n/a')
+            scope.set_tag('overcommit_limit', 'n/a')
+
+        for k, v in vars(opts).items():
+            scope.set_tag(k, v)
+
+
+def process_crashfile(crashfile):
+    """Parse the contents of a crashfile and submit sentry messages"""
+    crash_info = read_crashfile(str(crashfile))
+    with sentry_sdk.push_scope() as scope:
+        scope.level = 'fatal'
+
+        # Extract node name
+        node_name = crash_info.pop('node').split('.')[-1]
+        scope.set_tag("node_name", node_name)
+
+        # Massage the traceback, extract the gist
+        traceback = crash_info.pop('traceback')
+        # last line is probably most informative summary
+        gist = traceback.splitlines()[-1]
+        exception_text_start = 1
+        for line in traceback.splitlines()[1:]:
+            if not line[0].isspace():
+                break
+            exception_text_start += 1
+
+        exception_text = '\n'.join(
+            traceback.splitlines()[exception_text_start:])
+
+        # Extract inputs, if present
+        inputs = crash_info.pop('inputs', None)
+        if inputs:
+            scope.set_extra('inputs', dict(inputs))
+
+        # Extract any other possible metadata in the crash file
+        for k, v in crash_info.items():
+            strv = list(_chunks(str(v)))
+            if len(strv) == 1:
+                scope.set_extra(k, strv[0])
+            else:
+                for i, chunk in enumerate(strv):
+                    scope.set_extra('%s_%02d' % (k, i), chunk)
+
+        fingerprint = ''
+        issue_title = '{}: {}'.format(node_name, gist)
+        for new_fingerprint, error_snippets in KNOWN_ERRORS.items():
+            for error_snippet in error_snippets:
+                if error_snippet in traceback:
+                    fingerprint = new_fingerprint
+                    issue_title = new_fingerprint
+                    break
+            if fingerprint:
+                break
+
+        message = issue_title + '\n\n'
+        message += exception_text[-(8192 - len(message)):]
+        if fingerprint:
+            sentry_sdk.add_breadcrumb(message=fingerprint, level='fatal')
+        else:
+            # remove file paths
+            fingerprint = re.sub(r"(/[^/ ]*)+/?", '', message)
+            # remove words containing numbers
+            fingerprint = re.sub(r"([a-zA-Z]*[0-9]+[a-zA-Z]*)+", '', fingerprint)
+            # adding the return code if it exists
+            for line in message.splitlines():
+                if line.startswith("Return code"):
+                    fingerprint += line
+                    break
+
+        scope.fingerprint = [fingerprint]
+        sentry_sdk.capture_message(message, 'fatal')
+
+
+def before_send(event, hints):
+    # Filtering log messages about crashed nodes
+    if 'logentry' in event and 'message' in event['logentry']:
+        msg = event['logentry']['message']
+        if msg.startswith("could not run node:"):
+            return None
+        elif msg.startswith("Saving crash info to "):
+            return None
+        elif re.match("Node .+ failed to run on host .+", msg):
+            return None
+
+    if 'breadcrumbs' in event and isinstance(event['breadcrumbs'], list):
+        fingerprints_to_propagate = ['no-disk-space', 'memory-error', 'permission-denied',
+                                     'keyboard-interrupt']
+        for bc in event['breadcrumbs']:
+            msg = bc.get('message', 'empty-msg')
+            if msg in fingerprints_to_propagate:
+                event['fingerprint'] = [msg]
+                break
+
+    return event
+
+
+def _chunks(string, length=CHUNK_SIZE):
+    """
+    Splits a string into smaller chunks
+
+    >>> list(_chunks('some longer string', length=3))
+    ['som', 'e l', 'ong', 'er ', 'str', 'ing', '.']
+
+    """
+    return (string[i:i + CHUNK_SIZE]
+            for i in range(0, len(string), length))
diff --git a/fmriprep/viz/__init__.py b/fmriprep/viz/__init__.py
deleted file mode 100644
index 719c96812..000000000
--- a/fmriprep/viz/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
-# vi: set ft=python sts=4 ts=4 sw=4 et:
-"""
-The fmriprep reporting engine for visual assessment
-"""
-from .reports import run_reports, generate_reports
-
-__all__ = ['run_reports', 'generate_reports']
diff --git a/fmriprep/viz/config.json b/fmriprep/viz/config.json
deleted file mode 100644
index 0e3f18511..000000000
--- a/fmriprep/viz/config.json
+++ /dev/null
@@ -1,151 +0,0 @@
-{
-"sections":
-[
-    {
-        "name": "Summary",
-        "reportlets":
-        [
-            {
-                "name": "anat/summary",
-                "file_pattern": "anat/.*_summary",
-                "raw": true
-            }
-        ]
-    },
-    {
-        "name": "Anatomical",
-        "reportlets":
-        [
-            {
-                "name": "anat/conform",
-                "file_pattern": "anat/.*_conform",
-                "raw": true
-            },
-            {
-                "name": "anat_preproc/t1_brain_seg",
-                "file_pattern": "anat/.*seg_brainmask",
-                "title": "Brain mask and brain tissue segmentation of the T1w",
-                "description": "This panel shows the template T1-weighted image (if several T1w images were found), with contours delineating the detected brain mask and brain tissue segmentations."
-            },
-            {
-                "name": "anat_preproc/t1_2_mni",
-                "file_pattern": "anat/.*t1_2_mni",
-                "title": "T1 to MNI registration",
-                "description": "Nonlinear mapping of the T1w image into MNI space. Hover on the panel with the mouse to transition between both spaces."
-            },
-            {
-                "name": "anat_preproc/reconall",
-                "file_pattern": "anat/.*reconall",
-                "title": "Surface reconstruction",
-                "description": "Surfaces (white and pial) reconstructed with FreeSurfer (<code>recon-all</code>) overlaid on the participant's T1w template."
-            }
-
-        ]
-    },
-    {
-        "name": "Fieldmaps",
-        "reportlets":
-        [
-            {
-                "name": "fmap/magnitude_mask",
-                "file_pattern": "fmap/.*fmap_mask",
-                "title": "Skull stripped magnitude image",
-                "description": "Brain extraction of the magnitude image from the fieldmap"
-            }
-        ]
-    },
-    {
-        "name": "Functional",
-        "reportlets":
-        [
-            {
-                "name": "epi/summary",
-                "file_pattern": "func/.*_summary",
-                "raw": true
-            },
-            {
-                "name": "epi/validation",
-                "file_pattern": "func/.*_validation\\.",
-                "raw": true
-            },
-            {
-                "name": "epi/fmpa_reg",
-                "file_pattern": "func/.*fmap_reg\\.",
-                "title": "Fieldmap to EPI registration",
-                "description": "Results of affine coregistration between the magnitude image of the fieldmap and the reference EPI image"
-            },
-            {
-                "name": "epi/fmpa_reg",
-                "file_pattern": "func/.*fmap_reg_vsm\\.",
-                "title": "Fieldmap",
-                "description": "Overlaid on the reference EPI image"
-            },
-            {
-                "name": "epi/unwarp",
-                "file_pattern": "func/.*_sdc_.*\\.",
-                "title": "Susceptibility distortion correction",
-                "description": "Results of performing susceptibility distortion correction (SDC) on the EPI"
-            },
-            {
-                "name": "epi/sdc_syn",
-                "file_pattern": "func/.*_forcedsyn",
-                "title": "Experimental fieldmap-less susceptibility distortion correction",
-                "description": "The dataset contained some fieldmap information, but the argument <code>--force-syn</code> was used. The higher-priority SDC method was used. Here, we show the results of performing SyN-based SDC on the EPI for comparison."
-            },
-            {
-                "name": "epi/rois",
-                "file_pattern": "func/.*_rois",
-                "title": "ROIs in BOLD space",
-                "description": "Brain mask calculated on the BOLD signal (red contour), along with the masks used for a/tCompCor.<br />The aCompCor mask (magenta contour) is a conservative CSF and white-matter mask for extracting physiological and movement confounds. <br />The fCompCor mask (blue contour) contains the top 5% most variable voxels within a heavily-eroded brain-mask."
-            },
-            {
-                "name": "epi_mean_t1_registration/flirt",
-                "file_pattern": "func/.*_flirtnobbr",
-                "title": "EPI to T1 registration",
-                "description": "FSL <code>flirt</code> was used to generate transformations from EPI space to T1 Space - BBR refinement rejected. Note that Nearest Neighbor interpolation is used in the reportlets in order to highlight potential spin-history and other artifacts, whereas final images are resampled using Lanczos interpolation."
-            },
-            {
-                "name": "epi_mean_t1_registration/coreg",
-                "file_pattern": "func/.*_coreg",
-                "title": "EPI to T1 registration",
-                "description": "<code>mri_coreg</code> (FreeSurfer) was used to generate transformations from EPI space to T1 Space - <code>bbregister</code> refinement rejected. Note that Nearest Neighbor interpolation is used in the reportlets in order to highlight potential spin-history and other artifacts, whereas final images are resampled using Lanczos interpolation."
-            },
-            {
-                "name": "epi_mean_t1_registration/flirtbbr",
-                "file_pattern": "func/.*_flirtbbr",
-                "title": "EPI to T1 registration",
-                "description": "FSL <code>flirt</code> was used to generate transformations from EPI-space to T1w-space - The white matter mask calculated with FSL <code>fast</code> (brain tissue segmentation) was used for BBR. Note that Nearest Neighbor interpolation is used in the reportlets in order to highlight potential spin-history and other artifacts, whereas final images are resampled using Lanczos interpolation."
-            },
-            {
-                "name": "epi_mean_t1_registration/bbregister",
-                "file_pattern": "func/.*_bbregister",
-                "title": "EPI to T1 registration",
-                "description": "<code>bbregister</code> was used to generate transformations from EPI-space to T1w-space. Note that Nearest Neighbor interpolation is used in the reportlets in order to highlight potential spin-history and other artifacts, whereas final images are resampled using Lanczos interpolation."
-            },
-            {
-                "name": "epi/carpetplot",
-                "file_pattern": "func/.*carpetplot",
-                "title": "BOLD Summary",
-                "description": "Summary statistics are plotted, which may reveal trends or artifacts in the BOLD data. Global signals calculated within the whole-brain (GS), within the white-matter (WM) and within cerebro-spinal fluid (CSF) show the mean BOLD signal in their corresponding masks. DVARS and FD show the standardized DVARS and framewise-displacement measures for each time point.<br />A carpet plot shows the time series for all voxels within the brain mask. Voxels are grouped into cortical (blue), and subcortical (orange) gray matter, cerebellum (green) and white matter and CSF (red), indicated by the color map on the left-hand side."
-            },
-            {
-                "name": "ica_aroma",
-                "file_pattern": "func/.*ica_aroma",
-                "title": "ICA AROMA",
-                "description": "Maps created with maximum intensity projection (glass brain) with a black brain outline. Right hand side of each map: time series (top in seconds), frequency spectrum (bottom in Hertz). Components classified as signal are plotted in green; noise components in red."
-            }
-        ]
-    },
-    {
-        "name": "About",
-        "reportlets":
-        [
-            {
-                "name": "anat/about",
-                "file_pattern": "anat/.*_about",
-                "raw": true
-            }
-        ]
-    }
-]
-}
diff --git a/fmriprep/viz/report.tpl b/fmriprep/viz/report.tpl
deleted file mode 100644
index 0272dd10d..000000000
--- a/fmriprep/viz/report.tpl
+++ /dev/null
@@ -1,186 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.12: http://docutils.sourceforge.net/" />
-<title></title>
-<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
-<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js" integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy" crossorigin="anonymous"></script>
-<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
-<style type="text/css">
-.sub-report-title {}
-.run-title {}
-
-h1 { padding-top: 35px; }
-h2 { padding-top: 20px; }
-h3 { padding-top: 15px; }
-
-.elem-desc {}
-.elem-filename {}
-
-div.elem-image {
-  width: 100%;
-  page-break-before:always;
-}
-
-.elem-image object.svg-reportlet {
-    width: 100%;
-    padding-bottom: 5px;
-}
-body {
-    padding: 65px 10px 10px;
-}
-
-.boiler-html {
-    font-family: "Bitstream Charter", "Georgia", Times;
-    margin: 20px 25px;
-    padding: 10px;
-    background-color: #F8F9FA;
-}
-
-div#boilerplate pre {
-    margin: 20px 25px;
-    padding: 10px;
-    background-color: #F8F9FA;
-}
-
-</style>
-</head>
-<body>
-
-
-<nav class="navbar fixed-top navbar-expand-lg navbar-light bg-light">
-<div class="collapse navbar-collapse">
-    <ul class="navbar-nav">
-    {% for sub_report in sections %}
-        {% if sub_report.isnested %}
-        <li class="nav-item dropdown">
-            <a class="nav-link dropdown-toggle" id="navbar{{ sub_report.name }}" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false" href="#">{{ sub_report.name }}</a>
-            <div class="dropdown-menu" aria-labelledby="navbar{{ sub_report.name }}">
-                {% for run_report in sub_report.reportlets %}
-                <a class="dropdown-item" href="#{{run_report.name}}">{{run_report.title}}</a>
-                {% endfor %}
-            </div>
-        </li>
-        {% else %}
-        <li class="nav-item"><a class="nav-link" href="#{{sub_report.name}}">{{sub_report.name}}</a></li>
-        {% endif %}
-    {% endfor %}
-        <li class="nav-item"><a class="nav-link" href="#boilerplate">Methods</a></li>
-        <li class="nav-item"><a class="nav-link" href="#errors">Errors</a></li>
-    </ul>
-</div>
-</nav>
-<noscript>
-    <h1 class="text-danger"> The navigation menu uses Javascript. Without it this report might not work as expected </h1>
-</noscript>
-
-{% for sub_report in sections %}
-    <div id="{{ sub_report.name }}">
-    <h1 class="sub-report-title">{{ sub_report.name }}</h1>
-    {% if sub_report.isnested %}
-        {% for run_report in sub_report.reportlets %}
-            <div id="{{run_report.name}}">
-                <h2 class="run-title">Reports for {{ run_report.title }}</h2>
-                {% for elem in run_report.reportlets %}
-                    {% if elem.contents %}
-                        {% if elem.title %}<h3 class="elem-title">{{ elem.title }}</h3>{% endif %}
-                        {% if elem.description %}<p class="elem-desc">{{ elem.description }}<p>{% endif %}
-                        {% for content in elem.contents %}
-                            {% if elem.raw %}{{ content }}{% else %}
-                            <div class="elem-image">
-                            <object class="svg-reportlet" type="image/svg+xml" data="./{{ content }}">
-                            Problem loading figure {{ content }}. If the link below works, please try reloading the report in your browser.</object>
-                            </div>
-                            <div class="elem-filename">
-                                Get figure file: <a href="./{{ content }}" target="_blank">{{ content }}</a>
-                            </div>
-                            {% endif %}
-                        {% endfor %}
-                    {% endif %}
-                {% endfor %}
-            </div>
-        {% endfor %}
-    {% else %}
-        {% for elem in sub_report.reportlets %}
-            {% if elem.contents %}
-                {% if elem.title %}<h3 class="elem-title">{{ elem.title }}</h3>{% endif %}
-                {% if elem.description %}<p class="elem-desc">{{ elem.description }}<p><br />{% endif %}
-                {% for content in elem.contents %}
-                    {% if elem.raw %}{{ content }}{% else %}
-                        <div class="elem-image">
-                        <object class="svg-reportlet" type="image/svg+xml" data="./{{ content }}">filename:{{ content }}</object>
-                        </div>
-                        <div class="elem-filename">
-                            Get figure file: <a href="./{{ content }}" target="_blank">{{ content }}</a>
-                        </div>
-                    {% endif %}
-                {% endfor %}
-            {% endif %}
-        {% endfor %}
-    {% endif %}
-    </div>
-{% endfor %}
-
-<div id="boilerplate">
-    <h1 class="sub-report-title">Methods</h1>
-    {% if boilerplate %}
-    <p>We kindly ask to report results preprocessed with fMRIPrep using the following
-       boilerplate</p>
-    <ul class="nav nav-tabs" id="myTab" role="tablist">
-        {% for b in boilerplate %}
-        <li class="nav-item">
-            <a class="nav-link {% if b[0] == 0 %}active{% endif %}" id="{{ b[1] }}-tab" data-toggle="tab" href="#{{ b[1] }}" role="tab" aria-controls="{{ b[1] }}" aria-selected="{% if b[0] == 0 %}true{%else%}false{% endif %}">{{ b[1] }}</a>
-        </li>
-        {% endfor %}
-    </ul>
-    <div class="tab-content" id="myTabContent">
-      {% for b in boilerplate %}
-      <div class="tab-pane fade {% if b[0] == 0 %}active show{% endif %}" id="{{ b[1] }}" role="tabpanel" aria-labelledby="{{ b[1] }}-tab">{{ b[2] }}</div>
-      {% endfor %}
-    </div>
-    {% else %}
-    <p class="text-danger">Failed to generate the boilerplate</p>
-    {% endif %}
-    <p>Alternatively, an interactive <a href="http://fmriprep.readthedocs.io/en/latest/citing.html">boilerplate generator</a> is available in the <a href="https://fmriprep.org">documentation website</a>.</p>
-</div>
-
-<div id="errors">
-    <h1 class="sub-report-title">Errors</h1>
-    <ul>
-    {% for error in errors %}
-        <li>
-        <div class="nipype_error">
-            Node Name: <a target="_self" onclick="toggle('{{error.file|replace('.', '')}}_details_id');">{{ error.node }}</a><br>
-            <div id="{{error.file|replace('.', '')}}_details_id" style="display:none">
-            File: <code>{{ error.file }}</code><br>
-            Working Directory: <code>{{ error.node_dir }}</code><br>
-            Inputs: <br>
-            <ul>
-            {% for name, spec in error.inputs %}
-                <li>{{ name }}: <code>{{ spec }}</code></li>
-            {% endfor %}
-            </ul>
-            <pre>{{ error.traceback }}</pre>
-            </div>
-        </div>
-        </li>
-    {% else %}
-        <li>No errors to report!</li>
-    {% endfor %}
-    </ul>
-</div>
-
-
-<script type="text/javascript">
-    function toggle(id) {
-        var element = document.getElementById(id);
-        if(element.style.display == 'block')
-            element.style.display = 'none';
-        else
-            element.style.display = 'block';
-    }
-</script>
-</body>
-</html>
diff --git a/fmriprep/viz/reports.py b/fmriprep/viz/reports.py
deleted file mode 100644
index e2123eb01..000000000
--- a/fmriprep/viz/reports.py
+++ /dev/null
@@ -1,366 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
-# vi: set ft=python sts=4 ts=4 sw=4 et:
-"""
-fMRIprep reports builder
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-
-"""
-from pathlib import Path
-import json
-import re
-
-import jinja2
-from nipype.utils.filemanip import copyfile
-from pkg_resources import resource_filename as pkgrf
-
-from niworkflows.utils.misc import read_crashfile
-
-
-class Element(object):
-    """
-    Just a basic component of a report
-    """
-    def __init__(self, name, title=None):
-        self.name = name
-        self.title = title
-
-
-class Reportlet(Element):
-    """
-    A reportlet has title, description and a list of graphical components
-    """
-    def __init__(self, name, file_pattern=None, title=None, description=None, raw=False):
-        self.name = name
-        self.file_pattern = re.compile(file_pattern)
-        self.title = title
-        self.description = description
-        self.source_files = []
-        self.contents = []
-        self.raw = raw
-
-
-class SubReport(Element):
-    """
-    SubReports are sections within a Report
-    """
-    def __init__(self, name, reportlets=None, title=''):
-        self.name = name
-        self.title = title
-        self.reportlets = []
-        if reportlets:
-            self.reportlets += reportlets
-        self.isnested = False
-
-
-class Report(object):
-    """
-    The full report object
-    """
-    def __init__(self, path, config, out_dir, run_uuid, out_filename='report.html',
-                 sentry_sdk=None):
-        self.root = path
-        self.sections = []
-        self.errors = []
-        self.out_dir = Path(out_dir)
-        self.out_filename = out_filename
-        self.run_uuid = run_uuid
-        self.sentry_sdk = sentry_sdk
-
-        self._load_config(config)
-
-    def _load_config(self, config):
-        with open(config, 'r') as configfh:
-            config = json.load(configfh)
-
-        self.index(config['sections'])
-
-    def index(self, config):
-        fig_dir = 'figures'
-        subject_dir = self.root.split('/')[-1]
-        subject = re.search('^(?P<subject_id>sub-[a-zA-Z0-9]+)$', subject_dir).group()
-        svg_dir = self.out_dir / 'fmriprep' / subject / fig_dir
-        svg_dir.mkdir(parents=True, exist_ok=True)
-        reportlet_list = list(sorted([str(f) for f in Path(self.root).glob('**/*.*')]))
-
-        for subrep_cfg in config:
-            reportlets = []
-            for reportlet_cfg in subrep_cfg['reportlets']:
-                rlet = Reportlet(**reportlet_cfg)
-                for src in reportlet_list:
-                    ext = src.split('.')[-1]
-                    if rlet.file_pattern.search(src):
-                        contents = None
-                        if ext == 'html':
-                            with open(src) as fp:
-                                contents = fp.read().strip()
-                        elif ext == 'svg':
-                            fbase = Path(src).name
-                            copyfile(src, str(svg_dir / fbase),
-                                     copy=True, use_hardlink=True)
-                            contents = str(Path(subject) / fig_dir / fbase)
-
-                        if contents:
-                            rlet.source_files.append(src)
-                            rlet.contents.append(contents)
-
-                if rlet.source_files:
-                    reportlets.append(rlet)
-
-            if reportlets:
-                sub_report = SubReport(
-                    subrep_cfg['name'], reportlets=reportlets,
-                    title=subrep_cfg.get('title'))
-                self.sections.append(order_by_run(sub_report))
-
-        error_dir = self.out_dir / "fmriprep" / subject / 'log' / self.run_uuid
-        if error_dir.is_dir():
-            self.index_error_dir(error_dir)
-
-    def index_error_dir(self, error_dir):
-        """
-        Crawl subjects crash directory for the corresponding run, report to sentry, and
-        populate self.errors.
-        """
-        for crashfile in error_dir.glob('crash*.*'):
-            crash_info = read_crashfile(str(crashfile))
-            if self.sentry_sdk:
-                with self.sentry_sdk.push_scope() as scope:
-                    node_name = crash_info['node'].split('.')[-1]
-                    # last line is probably most informative summary
-                    gist = crash_info['traceback'].split('\n')[-1]
-                    exception_text_start = 1
-                    for line in crash_info['traceback'].split('\n')[1:]:
-                        if not line[0].isspace():
-                            break
-                        exception_text_start += 1
-
-                    exception_text = '\n'.join(crash_info['traceback'].split('\n')[
-                                     exception_text_start:])
-
-                    scope.set_tag("node_name", node_name)
-
-                    chunk_size = 16384
-
-                    for k, v in crash_info.items():
-                        if k == 'inputs':
-                            scope.set_extra(k, dict(v))
-                        elif isinstance(v, str) and len(v) > chunk_size:
-                            chunks = [v[i:i + chunk_size] for i in range(0, len(v), chunk_size)]
-                            for i, chunk in enumerate(chunks):
-                                scope.set_extra('%s_%02d' % (k, i), chunk)
-                        else:
-                            scope.set_extra(k, v)
-                    scope.level = 'fatal'
-
-                    # Group common events with pre specified fingerprints
-                    fingerprint_dict = {'permission-denied': [
-                                            "PermissionError: [Errno 13] Permission denied"],
-                                        'memory-error': ["MemoryError", "Cannot allocate memory"],
-                                        'reconall-already-running': [
-                                            "ERROR: it appears that recon-all is already running"],
-                                        'no-disk-space': [
-                                            "OSError: [Errno 28] No space left on device",
-                                            "[Errno 122] Disk quota exceeded"],
-                                        'sigkill': ["Return code: 137"],
-                                        'keyboard-interrupt': ["KeyboardInterrupt"]}
-
-                    fingerprint = ''
-                    issue_title = node_name + ': ' + gist
-                    for new_fingerprint, error_snippets in fingerprint_dict.items():
-                        for error_snippet in error_snippets:
-                            if error_snippet in crash_info['traceback']:
-                                fingerprint = new_fingerprint
-                                issue_title = new_fingerprint
-                                break
-                        if fingerprint:
-                            break
-
-                    message = issue_title + '\n\n'
-                    message += exception_text[-(8192-len(message)):]
-                    if fingerprint:
-                        self.sentry_sdk.add_breadcrumb(message=fingerprint, level='fatal')
-                    else:
-                        # remove file paths
-                        fingerprint = re.sub(r"(/[^/ ]*)+/?", '', message)
-                        # remove words containing numbers
-                        fingerprint = re.sub(r"([a-zA-Z]*[0-9]+[a-zA-Z]*)+", '', fingerprint)
-                        # adding the return code if it exists
-                        for line in message.split('\n'):
-                            if line.startswith("Return code"):
-                                fingerprint += line
-                                break
-
-                    scope.fingerprint = [fingerprint]
-                    self.sentry_sdk.capture_message(message, 'fatal')
-
-            self.errors.append(crash_info)
-
-    def generate_report(self):
-        logs_path = self.out_dir / 'fmriprep' / 'logs'
-
-        boilerplate = []
-        boiler_idx = 0
-
-        if (logs_path / 'CITATION.html').exists():
-            text = (logs_path / 'CITATION.html').read_text(encoding='UTF-8')
-            text = '<div class="boiler-html">%s</div>' % re.compile(
-                '<body>(.*?)</body>',
-                re.DOTALL | re.IGNORECASE).findall(text)[0].strip()
-            boilerplate.append((boiler_idx, 'HTML', text))
-            boiler_idx += 1
-
-        if (logs_path / 'CITATION.md').exists():
-            text = '<pre>%s</pre>\n' % (logs_path / 'CITATION.md').read_text(encoding='UTF-8')
-            boilerplate.append((boiler_idx, 'Markdown', text))
-            boiler_idx += 1
-
-        if (logs_path / 'CITATION.tex').exists():
-            text = (logs_path / 'CITATION.tex').read_text(encoding='UTF-8')
-            text = re.compile(
-                r'\\begin{document}(.*?)\\end{document}',
-                re.DOTALL | re.IGNORECASE).findall(text)[0].strip()
-            text = '<pre>%s</pre>\n' % text
-            text += '<h3>Bibliography</h3>\n'
-            text += '<pre>%s</pre>\n' % Path(
-                pkgrf('fmriprep', 'data/boilerplate.bib')).read_text(encoding='UTF-8')
-            boilerplate.append((boiler_idx, 'LaTeX', text))
-            boiler_idx += 1
-
-        searchpath = pkgrf('fmriprep', '/')
-        env = jinja2.Environment(
-            loader=jinja2.FileSystemLoader(searchpath=searchpath),
-            trim_blocks=True, lstrip_blocks=True
-        )
-        report_tpl = env.get_template('viz/report.tpl')
-        report_render = report_tpl.render(sections=self.sections, errors=self.errors,
-                                          boilerplate=boilerplate)
-
-        # Write out report
-        (self.out_dir / 'fmriprep' / self.out_filename).write_text(report_render, encoding='UTF-8')
-        return len(self.errors)
-
-
-def order_by_run(subreport):
-    ordered = []
-    run_reps = {}
-
-    for element in subreport.reportlets:
-        if len(element.source_files) == 1 and element.source_files[0]:
-            ordered.append(element)
-            continue
-
-        for filename, file_contents in zip(element.source_files, element.contents):
-            name, title = generate_name_title(filename)
-            if not filename or not name:
-                continue
-
-            new_element = Reportlet(
-                name=element.name, title=element.title, file_pattern=element.file_pattern,
-                description=element.description, raw=element.raw)
-            new_element.contents.append(file_contents)
-            new_element.source_files.append(filename)
-
-            if name not in run_reps:
-                run_reps[name] = SubReport(name, title=title)
-
-            run_reps[name].reportlets.append(new_element)
-
-    if run_reps:
-        keys = list(sorted(run_reps.keys()))
-        for key in keys:
-            ordered.append(run_reps[key])
-        subreport.isnested = True
-
-    subreport.reportlets = ordered
-    return subreport
-
-
-def generate_name_title(filename):
-    fname = Path(filename).name
-    expr = re.compile('^sub-(?P<subject_id>[a-zA-Z0-9]+)(_ses-(?P<session_id>[a-zA-Z0-9]+))?'
-                      '(_task-(?P<task_id>[a-zA-Z0-9]+))?(_acq-(?P<acq_id>[a-zA-Z0-9]+))?'
-                      '(_rec-(?P<rec_id>[a-zA-Z0-9]+))?(_run-(?P<run_id>[a-zA-Z0-9]+))?')
-    outputs = expr.search(fname)
-    if outputs:
-        outputs = outputs.groupdict()
-    else:
-        return None, None
-
-    name = '{session}{task}{acq}{rec}{run}'.format(
-        session="_ses-" + outputs['session_id'] if outputs['session_id'] else '',
-        task="_task-" + outputs['task_id'] if outputs['task_id'] else '',
-        acq="_acq-" + outputs['acq_id'] if outputs['acq_id'] else '',
-        rec="_rec-" + outputs['rec_id'] if outputs['rec_id'] else '',
-        run="_run-" + outputs['run_id'] if outputs['run_id'] else ''
-    )
-    title = '{session}{task}{acq}{rec}{run}'.format(
-        session=" Session: " + outputs['session_id'] if outputs['session_id'] else '',
-        task=" Task: " + outputs['task_id'] if outputs['task_id'] else '',
-        acq=" Acquisition: " + outputs['acq_id'] if outputs['acq_id'] else '',
-        rec=" Reconstruction: " + outputs['rec_id'] if outputs['rec_id'] else '',
-        run=" Run: " + outputs['run_id'] if outputs['run_id'] else ''
-    )
-    return name.strip('_'), title
-
-
-def run_reports(reportlets_dir, out_dir, subject_label, run_uuid, sentry_sdk=None):
-    """
-    Runs the reports
-
-    >>> import os
-    >>> from shutil import copytree
-    >>> from tempfile import TemporaryDirectory
-    >>> filepath = os.path.dirname(os.path.realpath(__file__))
-    >>> test_data_path = os.path.realpath(os.path.join(filepath,
-    ...                                   '../data/tests/work'))
-    >>> curdir = os.getcwd()
-    >>> tmpdir = TemporaryDirectory()
-    >>> os.chdir(tmpdir.name)
-    >>> data_dir = copytree(test_data_path, os.path.abspath('work'))
-    >>> os.makedirs('out/fmriprep', exist_ok=True)
-    >>> run_reports(os.path.abspath('work/reportlets'),
-    ...             os.path.abspath('out'),
-    ...             '01', 'madeoutuuid')
-    0
-    >>> os.chdir(curdir)
-    >>> tmpdir.cleanup()
-
-    """
-    reportlet_path = str(Path(reportlets_dir) / 'fmriprep' / ("sub-%s" % subject_label))
-    config = pkgrf('fmriprep', 'viz/config.json')
-
-    out_filename = 'sub-{}.html'.format(subject_label)
-    report = Report(reportlet_path, config, out_dir, run_uuid, out_filename, sentry_sdk=sentry_sdk)
-    return report.generate_report()
-
-
-def generate_reports(subject_list, output_dir, work_dir, run_uuid, sentry_sdk=None):
-    """
-    A wrapper to run_reports on a given ``subject_list``
-    """
-    reports_dir = str(Path(work_dir) / 'reportlets')
-    report_errors = [
-        run_reports(reports_dir, output_dir, subject_label, run_uuid=run_uuid,
-                    sentry_sdk=sentry_sdk)
-        for subject_label in subject_list
-    ]
-
-    errno = sum(report_errors)
-    if errno:
-        import logging
-        logger = logging.getLogger('cli')
-        error_list = ', '.join('%s (%d)' % (subid, err)
-                               for subid, err in zip(subject_list, report_errors) if err)
-
-        err_msg = 'Preprocessing did not finish successfully. Errors occurred while processing ' \
-                  'data from participants: %s. Check the HTML reports for details.' % error_list
-        if sentry_sdk:
-            with sentry_sdk.push_scope() as scope:
-                scope.fingerprint = ['fMRIPrep finished with errors']
-                logger.error(err_msg)
-        else:
-            logger.error(err_msg)
-    return errno
diff --git a/fmriprep/workflows/base.py b/fmriprep/workflows/base.py
index a43d2e1be..efb57097c 100755
--- a/fmriprep/workflows/base.py
+++ b/fmriprep/workflows/base.py
@@ -13,6 +13,7 @@
 
 import sys
 import os
+from collections import OrderedDict
 from copy import deepcopy
 
 from nipype import __version__ as nipype_ver
@@ -33,12 +34,38 @@
 from .bold import init_func_preproc_wf
 
 
-def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir, output_dir,
-                     ignore, debug, low_mem, anat_only, longitudinal, t2s_coreg,
-                     omp_nthreads, skull_strip_template, skull_strip_fixed_seed,
-                     freesurfer, output_spaces, template, medial_surface_nan, cifti_output, hires,
-                     use_bbr, bold2t1w_dof, fmap_bspline, fmap_demean, use_syn, force_syn,
-                     use_aroma, err_on_aroma_warn, aroma_melodic_dim, template_out_grid):
+def init_fmriprep_wf(
+    anat_only,
+    aroma_melodic_dim,
+    bold2t1w_dof,
+    cifti_output,
+    debug,
+    echo_idx,
+    err_on_aroma_warn,
+    fmap_bspline,
+    fmap_demean,
+    force_syn,
+    freesurfer,
+    hires,
+    ignore,
+    layout,
+    longitudinal,
+    low_mem,
+    medial_surface_nan,
+    omp_nthreads,
+    output_dir,
+    output_spaces,
+    run_uuid,
+    skull_strip_fixed_seed,
+    skull_strip_template,
+    subject_list,
+    t2s_coreg,
+    task_id,
+    use_aroma,
+    use_bbr,
+    use_syn,
+    work_dir,
+):
     """
     This workflow organizes the execution of FMRIPREP, with a sub-workflow for
     each subject.
@@ -51,43 +78,44 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
         :simple_form: yes
 
         import os
-        from collections import namedtuple
+        from collections import namedtuple, OrderedDict
         BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
         from fmriprep.workflows.base import init_fmriprep_wf
         os.environ['FREESURFER_HOME'] = os.getcwd()
-        wf = init_fmriprep_wf(layout=BIDSLayout(),
-                              subject_list=['fmripreptest'],
-                              task_id='',
-                              echo_idx=None,
-                              run_uuid='X',
-                              work_dir='.',
-                              output_dir='.',
-                              ignore=[],
-                              debug=False,
-                              low_mem=False,
-                              anat_only=False,
-                              longitudinal=False,
-                              t2s_coreg=False,
-                              omp_nthreads=1,
-                              skull_strip_template='OASIS30ANTs',
-                              skull_strip_fixed_seed=False,
-                              freesurfer=True,
-                              output_spaces=['T1w', 'fsnative',
-                                            'template', 'fsaverage5'],
-                              template='MNI152NLin2009cAsym',
-                              medial_surface_nan=False,
-                              cifti_output=False,
-                              hires=True,
-                              use_bbr=True,
-                              bold2t1w_dof=9,
-                              fmap_bspline=False,
-                              fmap_demean=True,
-                              use_syn=True,
-                              force_syn=True,
-                              use_aroma=False,
-                              err_on_aroma_warn=False,
-                              aroma_melodic_dim=-200,
-                              template_out_grid='native')
+        wf = init_fmriprep_wf(
+            anat_only=False,
+            aroma_melodic_dim=-200,
+            bold2t1w_dof=9,
+            cifti_output=False,
+            debug=False,
+            echo_idx=None,
+            err_on_aroma_warn=False,
+            fmap_bspline=False,
+            fmap_demean=True,
+            force_syn=True,
+            freesurfer=True,
+            hires=True,
+            ignore=[],
+            layout=BIDSLayout(),
+            longitudinal=False,
+            low_mem=False,
+            medial_surface_nan=False,
+            omp_nthreads=1,
+            output_dir='.',
+            output_spaces=OrderedDict([
+                ('MNI152Lin', {}), ('fsaverage', {'density': '10k'}),
+                ('T1w', {}), ('fsnative', {})]),
+            run_uuid='X',
+            skull_strip_fixed_seed=False,
+            skull_strip_template='OASIS30ANTs',
+            subject_list=['fmripreptest'],
+            t2s_coreg=False,
+            task_id='',
+            use_aroma=False,
+            use_bbr=True,
+            use_syn=True,
+            work_dir='.',
+        )
 
 
     Parameters
@@ -129,18 +157,14 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
             run-to-run replicability when used with --omp-nthreads 1
         freesurfer : bool
             Enable FreeSurfer surface reconstruction (may increase runtime)
-        output_spaces : list
-            List of output spaces functional images are to be resampled to.
-            Some parts of pipeline will only be instantiated for some output spaces.
-
-            Valid spaces:
-
-             - T1w
-             - template
-             - fsnative
-             - fsaverage (or other pre-existing FreeSurfer templates)
-        template : str
-            Name of template targeted by ``template`` output space
+        output_spaces : OrderedDict
+            Ordered dictionary where keys are TemplateFlow ID strings (e.g. ``MNI152Lin``,
+            ``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, or ``fsLR``) strings designating
+            nonstandard references (e.g. ``T1w`` or ``anat``, ``sbref``, ``run``, etc.),
+            or paths pointing to custom templates organized in a TemplateFlow-like structure.
+            Values of the dictionary aggregate modifiers (e.g. the value for the key ``MNI152Lin``
+            could be ``{'resolution': 2}`` if one wants the resampling to be done on the 2mm
+            resolution version of the selected template).
         medial_surface_nan : bool
             Replace medial wall values with NaNs on functional GIFTI files
         cifti_output : bool
@@ -165,9 +189,6 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
             Perform ICA-AROMA on MNI-resampled functional series
         err_on_aroma_warn : bool
             Do not fail on ICA-AROMA errors
-        template_out_grid : str
-            Keyword ('native', '1mm' or '2mm') or path of custom reference
-            image for normalization
 
     """
     fmriprep_wf = Workflow(name='fmriprep_wf')
@@ -178,7 +199,8 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
             BIDSFreeSurferDir(
                 derivatives=output_dir,
                 freesurfer_home=os.getenv('FREESURFER_HOME'),
-                spaces=output_spaces),
+                spaces=[s for s in output_spaces.keys() if s.startswith('fsaverage')] + [
+                    'fsnative'] * ('fsnative' in output_spaces)),
             name='fsdir_run_' + run_uuid.replace('-', '_'), run_without_submitting=True)
 
     reportlets_dir = os.path.join(work_dir, 'reportlets')
@@ -202,7 +224,6 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
             skull_strip_fixed_seed=skull_strip_fixed_seed,
             freesurfer=freesurfer,
             output_spaces=output_spaces,
-            template=template,
             medial_surface_nan=medial_surface_nan,
             cifti_output=cifti_output,
             hires=hires,
@@ -212,7 +233,6 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
             fmap_demean=fmap_demean,
             use_syn=use_syn,
             force_syn=force_syn,
-            template_out_grid=template_out_grid,
             use_aroma=use_aroma,
             aroma_melodic_dim=aroma_melodic_dim,
             err_on_aroma_warn=err_on_aroma_warn,
@@ -232,13 +252,38 @@ def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid, work_dir
     return fmriprep_wf
 
 
-def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportlets_dir,
-                           output_dir, ignore, debug, low_mem, anat_only, longitudinal, t2s_coreg,
-                           omp_nthreads, skull_strip_template, skull_strip_fixed_seed,
-                           freesurfer, output_spaces, template, medial_surface_nan,
-                           cifti_output, hires, use_bbr, bold2t1w_dof, fmap_bspline, fmap_demean,
-                           use_syn, force_syn, template_out_grid,
-                           use_aroma, aroma_melodic_dim, err_on_aroma_warn):
+def init_single_subject_wf(
+    anat_only,
+    aroma_melodic_dim,
+    bold2t1w_dof,
+    cifti_output,
+    debug,
+    echo_idx,
+    err_on_aroma_warn,
+    fmap_bspline,
+    fmap_demean,
+    force_syn,
+    freesurfer,
+    hires,
+    ignore,
+    layout,
+    longitudinal,
+    low_mem,
+    medial_surface_nan,
+    name,
+    omp_nthreads,
+    output_dir,
+    output_spaces,
+    reportlets_dir,
+    skull_strip_fixed_seed,
+    skull_strip_template,
+    subject_id,
+    t2s_coreg,
+    task_id,
+    use_aroma,
+    use_bbr,
+    use_syn,
+):
     """
     This workflow organizes the preprocessing pipeline for a single subject.
     It collects and reports information about the subject, and prepares
@@ -254,120 +299,117 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
         :simple_form: yes
 
         from fmriprep.workflows.base import init_single_subject_wf
-        from collections import namedtuple
+        from collections import namedtuple, OrderedDict
         BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
-        wf = init_single_subject_wf(layout=BIDSLayout(),
-                                    subject_id='test',
-                                    task_id='',
-                                    echo_idx=None,
-                                    name='single_subject_wf',
-                                    reportlets_dir='.',
-                                    output_dir='.',
-                                    ignore=[],
-                                    debug=False,
-                                    low_mem=False,
-                                    anat_only=False,
-                                    longitudinal=False,
-                                    t2s_coreg=False,
-                                    omp_nthreads=1,
-                                    skull_strip_template='OASIS30ANTs',
-                                    skull_strip_fixed_seed=False,
-                                    freesurfer=True,
-                                    template='MNI152NLin2009cAsym',
-                                    output_spaces=['T1w', 'fsnative',
-                                                  'template', 'fsaverage5'],
-                                    medial_surface_nan=False,
-                                    cifti_output=False,
-                                    hires=True,
-                                    use_bbr=True,
-                                    bold2t1w_dof=9,
-                                    fmap_bspline=False,
-                                    fmap_demean=True,
-                                    use_syn=True,
-                                    force_syn=True,
-                                    template_out_grid='native',
-                                    use_aroma=False,
-                                    aroma_melodic_dim=-200,
-                                    err_on_aroma_warn=False)
+        wf = init_single_subject_wf(
+            anat_only=False,
+            aroma_melodic_dim=-200,
+            bold2t1w_dof=9,
+            cifti_output=False,
+            debug=False,
+            echo_idx=None,
+            err_on_aroma_warn=False,
+            fmap_bspline=False,
+            fmap_demean=True,
+            force_syn=True,
+            freesurfer=True,
+            hires=True,
+            ignore=[],
+            layout=BIDSLayout(),
+            longitudinal=False,
+            low_mem=False,
+            medial_surface_nan=False,
+            name='single_subject_wf',
+            omp_nthreads=1,
+            output_dir='.',
+            output_spaces=OrderedDict([
+                ('MNI152Lin', {}), ('fsaverage', {'density': '10k'}),
+                ('T1w', {}), ('fsnative', {})]),
+            reportlets_dir='.',
+            skull_strip_fixed_seed=False,
+            skull_strip_template='OASIS30ANTs',
+            subject_id='test',
+            t2s_coreg=False,
+            task_id='',
+            use_aroma=False,
+            use_bbr=True,
+            use_syn=True,
+        )
 
     Parameters
 
-        layout : BIDSLayout object
-            BIDS dataset layout
-        subject_id : str
-            List of subject labels
-        task_id : str or None
-            Task ID of BOLD series to preprocess, or ``None`` to preprocess all
+        anat_only : bool
+            Disable functional workflows
+        aroma_melodic_dim : int
+            Maximum number of components identified by MELODIC within ICA-AROMA
+            (default is -200, ie. no limitation).
+        bold2t1w_dof : 6, 9 or 12
+            Degrees-of-freedom for BOLD-T1w registration
+        cifti_output : bool
+            Generate bold CIFTI file in output spaces
+        debug : bool
+            Enable debugging outputs
         echo_idx : int or None
             Index of echo to preprocess in multiecho BOLD series,
             or ``None`` to preprocess all
-        name : str
-            Name of workflow
+        err_on_aroma_warn : bool
+            Do not fail on ICA-AROMA errors
+        fmap_bspline : bool
+            **Experimental**: Fit B-Spline field using least-squares
+        fmap_demean : bool
+            Demean voxel-shift map during unwarp
+        force_syn : bool
+            **Temporary**: Always run SyN-based SDC
+        freesurfer : bool
+            Enable FreeSurfer surface reconstruction (may increase runtime)
+        hires : bool
+            Enable sub-millimeter preprocessing in FreeSurfer
         ignore : list
             Preprocessing steps to skip (may include "slicetiming", "fieldmaps")
-        debug : bool
-            Enable debugging outputs
-        low_mem : bool
-            Write uncompressed .nii files in some cases to reduce memory usage
-        anat_only : bool
-            Disable functional workflows
+        layout : BIDSLayout object
+            BIDS dataset layout
         longitudinal : bool
             Treat multiple sessions as longitudinal (may increase runtime)
             See sub-workflows for specific differences
-        t2s_coreg : bool
-            For multi-echo EPI, use the calculated T2*-map for T2*-driven coregistration
+        low_mem : bool
+            Write uncompressed .nii files in some cases to reduce memory usage
+        medial_surface_nan : bool
+            Replace medial wall values with NaNs on functional GIFTI files
+        name : str
+            Name of workflow
         omp_nthreads : int
             Maximum number of threads an individual process may use
-        skull_strip_template : str
-            Name of ANTs skull-stripping template ('OASIS30ANTs' or 'NKI')
+        output_dir : str
+            Directory in which to save derivatives
+        output_spaces : OrderedDict
+            Ordered dictionary where keys are TemplateFlow ID strings (e.g. ``MNI152Lin``,
+            ``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, or ``fsLR``) strings designating
+            nonstandard references (e.g. ``T1w`` or ``anat``, ``sbref``, ``run``, etc.),
+            or paths pointing to custom templates organized in a TemplateFlow-like structure.
+            Values of the dictionary aggregate modifiers (e.g. the value for the key ``MNI152Lin``
+            could be ``{'resolution': 2}`` if one wants the resampling to be done on the 2mm
+            resolution version of the selected template).
+        reportlets_dir : str
+            Directory in which to save reportlets
         skull_strip_fixed_seed : bool
             Do not use a random seed for skull-stripping - will ensure
             run-to-run replicability when used with --omp-nthreads 1
-        reportlets_dir : str
-            Directory in which to save reportlets
-        output_dir : str
-            Directory in which to save derivatives
-        freesurfer : bool
-            Enable FreeSurfer surface reconstruction (may increase runtime)
-        output_spaces : list
-            List of output spaces functional images are to be resampled to.
-            Some parts of pipeline will only be instantiated for some output spaces.
-
-            Valid spaces:
-
-             - T1w
-             - template
-             - fsnative
-             - fsaverage (or other pre-existing FreeSurfer templates)
-        template : str
-            Name of template targeted by ``template`` output space
-        medial_surface_nan : bool
-            Replace medial wall values with NaNs on functional GIFTI files
-        cifti_output : bool
-            Generate bold CIFTI file in output spaces
-        hires : bool
-            Enable sub-millimeter preprocessing in FreeSurfer
+        skull_strip_template : str
+            Name of ANTs skull-stripping template ('OASIS30ANTs' or 'NKI')
+        subject_id : str
+            List of subject labels
+        t2s_coreg : bool
+            For multi-echo EPI, use the calculated T2*-map for T2*-driven coregistration
+        task_id : str or None
+            Task ID of BOLD series to preprocess, or ``None`` to preprocess all
+        use_aroma : bool
+            Perform ICA-AROMA on MNI-resampled functional series
         use_bbr : bool or None
             Enable/disable boundary-based registration refinement.
             If ``None``, test BBR result for distortion before accepting.
-        bold2t1w_dof : 6, 9 or 12
-            Degrees-of-freedom for BOLD-T1w registration
-        fmap_bspline : bool
-            **Experimental**: Fit B-Spline field using least-squares
-        fmap_demean : bool
-            Demean voxel-shift map during unwarp
         use_syn : bool
             **Experimental**: Enable ANTs SyN-based susceptibility distortion correction (SDC).
             If fieldmaps are present and enabled, this is not run, by default.
-        force_syn : bool
-            **Temporary**: Always run SyN-based SDC
-        template_out_grid : str
-            Keyword ('native', '1mm' or '2mm') or path of custom reference
-            image for normalization
-        use_aroma : bool
-            Perform ICA-AROMA on MNI-resampled functional series
-        err_on_aroma_warn : bool
-            Do not fail on ICA-AROMA errors
 
     Inputs
 
@@ -375,6 +417,7 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
             FreeSurfer SUBJECTS_DIR
 
     """
+    from .bold.resampling import NONSTANDARD_REFERENCES
     if name in ('single_subject_wf', 'single_subject_fmripreptest_wf'):
         # for documentation purposes
         subject_data = {
@@ -418,6 +461,11 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
 
 """.format(nilearn_ver=nilearn_ver)
 
+    # Filter out standard spaces to a separate dict
+    std_spaces = OrderedDict([
+        (key, modifiers) for key, modifiers in output_spaces.items()
+        if key not in NONSTANDARD_REFERENCES])
+
     inputnode = pe.Node(niu.IdentityInterface(fields=['subjects_dir']),
                         name='inputnode')
 
@@ -427,7 +475,7 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
     bids_info = pe.Node(BIDSInfo(
         bids_dir=layout.root, bids_validate=False), name='bids_info')
 
-    summary = pe.Node(SubjectSummary(output_spaces=output_spaces, template=template),
+    summary = pe.Node(SubjectSummary(output_spaces=list(std_spaces.keys())),
                       name='summary', run_without_submitting=True)
 
     about = pe.Node(AboutSummary(version=__version__,
@@ -436,12 +484,12 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
 
     ds_report_summary = pe.Node(
         DerivativesDataSink(base_directory=reportlets_dir,
-                            suffix='summary'),
+                            desc='summary', keep_dtype=True),
         name='ds_report_summary', run_without_submitting=True)
 
     ds_report_about = pe.Node(
         DerivativesDataSink(base_directory=reportlets_dir,
-                            suffix='about'),
+                            desc='about', keep_dtype=True),
         name='ds_report_about', run_without_submitting=True)
 
     # Preprocessing of T1w (includes registration to MNI)
@@ -449,17 +497,16 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
         bids_root=layout.root,
         debug=debug,
         freesurfer=freesurfer,
-        fs_spaces=output_spaces,
         hires=hires,
         longitudinal=longitudinal,
         name="anat_preproc_wf",
         num_t1w=len(subject_data['t1w']),
         omp_nthreads=omp_nthreads,
         output_dir=output_dir,
+        output_spaces=std_spaces,
         reportlets_dir=reportlets_dir,
         skull_strip_fixed_seed=skull_strip_fixed_seed,
         skull_strip_template=skull_strip_template,
-        template=template,
     )
 
     workflow.connect([
@@ -490,31 +537,31 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
         return workflow
 
     for bold_file in subject_data['bold']:
-        func_preproc_wf = init_func_preproc_wf(bold_file=bold_file,
-                                               layout=layout,
-                                               ignore=ignore,
-                                               freesurfer=freesurfer,
-                                               use_bbr=use_bbr,
-                                               t2s_coreg=t2s_coreg,
-                                               bold2t1w_dof=bold2t1w_dof,
-                                               reportlets_dir=reportlets_dir,
-                                               output_spaces=output_spaces,
-                                               template=template,
-                                               medial_surface_nan=medial_surface_nan,
-                                               cifti_output=cifti_output,
-                                               output_dir=output_dir,
-                                               omp_nthreads=omp_nthreads,
-                                               low_mem=low_mem,
-                                               fmap_bspline=fmap_bspline,
-                                               fmap_demean=fmap_demean,
-                                               use_syn=use_syn,
-                                               force_syn=force_syn,
-                                               debug=debug,
-                                               template_out_grid=template_out_grid,
-                                               use_aroma=use_aroma,
-                                               aroma_melodic_dim=aroma_melodic_dim,
-                                               err_on_aroma_warn=err_on_aroma_warn,
-                                               num_bold=len(subject_data['bold']))
+        func_preproc_wf = init_func_preproc_wf(
+            aroma_melodic_dim=aroma_melodic_dim,
+            bold2t1w_dof=bold2t1w_dof,
+            bold_file=bold_file,
+            cifti_output=cifti_output,
+            debug=debug,
+            err_on_aroma_warn=err_on_aroma_warn,
+            fmap_bspline=fmap_bspline,
+            fmap_demean=fmap_demean,
+            force_syn=force_syn,
+            freesurfer=freesurfer,
+            ignore=ignore,
+            layout=layout,
+            low_mem=low_mem,
+            medial_surface_nan=medial_surface_nan,
+            num_bold=len(subject_data['bold']),
+            omp_nthreads=omp_nthreads,
+            output_dir=output_dir,
+            output_spaces=output_spaces,
+            reportlets_dir=reportlets_dir,
+            t2s_coreg=t2s_coreg,
+            use_aroma=use_aroma,
+            use_bbr=use_bbr,
+            use_syn=use_syn,
+        )
 
         workflow.connect([
             (anat_preproc_wf, func_preproc_wf,
@@ -525,8 +572,12 @@ def init_single_subject_wf(layout, subject_id, task_id, echo_idx, name, reportle
               ('outputnode.t1_aseg', 'inputnode.t1_aseg'),
               ('outputnode.t1_aparc', 'inputnode.t1_aparc'),
               ('outputnode.t1_tpms', 'inputnode.t1_tpms'),
-              ('outputnode.t1_2_mni_forward_transform', 'inputnode.t1_2_mni_forward_transform'),
-              ('outputnode.t1_2_mni_reverse_transform', 'inputnode.t1_2_mni_reverse_transform'),
+              ('outputnode.template', 'inputnode.template'),
+              ('outputnode.forward_transform', 'inputnode.anat2std_xfm'),
+              ('outputnode.reverse_transform', 'inputnode.std2anat_xfm'),
+              ('outputnode.joint_template', 'inputnode.joint_template'),
+              ('outputnode.joint_forward_transform', 'inputnode.joint_anat2std_xfm'),
+              ('outputnode.joint_reverse_transform', 'inputnode.joint_std2anat_xfm'),
               # Undefined if --no-freesurfer, but this is safe
               ('outputnode.subjects_dir', 'inputnode.subjects_dir'),
               ('outputnode.subject_id', 'inputnode.subject_id'),
diff --git a/fmriprep/workflows/bold/__init__.py b/fmriprep/workflows/bold/__init__.py
index 25ae71d24..baf10de8a 100644
--- a/fmriprep/workflows/bold/__init__.py
+++ b/fmriprep/workflows/bold/__init__.py
@@ -27,7 +27,7 @@
     init_bold_reg_wf,
 )
 from .resampling import (
-    init_bold_mni_trans_wf,
+    init_bold_std_trans_wf,
     init_bold_surf_wf,
     init_bold_preproc_trans_wf,
 )
@@ -40,7 +40,7 @@
 __all__ = [
     'init_bold_confs_wf',
     'init_bold_hmc_wf',
-    'init_bold_mni_trans_wf',
+    'init_bold_std_trans_wf',
     'init_bold_preproc_trans_wf',
     'init_bold_reference_wf',
     'init_bold_reg_wf',
diff --git a/fmriprep/workflows/bold/base.py b/fmriprep/workflows/bold/base.py
index a760e0b56..65a03bb0c 100755
--- a/fmriprep/workflows/bold/base.py
+++ b/fmriprep/workflows/bold/base.py
@@ -11,6 +11,7 @@
 """
 
 import os
+from collections import OrderedDict
 
 import nibabel as nb
 from nipype import logging
@@ -20,8 +21,7 @@
 from nipype.interfaces import utility as niu
 
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
-from niworkflows.interfaces.cifti import GenerateCifti, CiftiNameSource
-from niworkflows.interfaces.surf import GiftiNameSource
+from niworkflows.interfaces.cifti import GenerateCifti
 
 from ...utils.meepi import combine_meepi_source
 
@@ -36,23 +36,41 @@
 from .registration import init_bold_t1_trans_wf, init_bold_reg_wf
 from .resampling import (
     init_bold_surf_wf,
-    init_bold_mni_trans_wf,
+    init_bold_std_trans_wf,
     init_bold_preproc_trans_wf,
 )
+from .outputs import init_func_derivatives_wf
 from .util import init_bold_reference_wf
 
 DEFAULT_MEMORY_MIN_GB = 0.01
 LOGGER = logging.getLogger('nipype.workflow')
 
 
-def init_func_preproc_wf(bold_file, ignore, freesurfer,
-                         use_bbr, t2s_coreg, bold2t1w_dof, reportlets_dir,
-                         output_spaces, template, output_dir, omp_nthreads,
-                         fmap_bspline, fmap_demean, use_syn, force_syn,
-                         use_aroma, err_on_aroma_warn, aroma_melodic_dim,
-                         medial_surface_nan, cifti_output,
-                         debug, low_mem, template_out_grid,
-                         layout=None, num_bold=1):
+def init_func_preproc_wf(
+    aroma_melodic_dim,
+    bold2t1w_dof,
+    bold_file,
+    cifti_output,
+    debug,
+    err_on_aroma_warn,
+    fmap_bspline,
+    fmap_demean,
+    force_syn,
+    freesurfer,
+    ignore,
+    low_mem,
+    medial_surface_nan,
+    omp_nthreads,
+    output_dir,
+    output_spaces,
+    reportlets_dir,
+    t2s_coreg,
+    use_aroma,
+    use_bbr,
+    use_syn,
+    layout=None,
+    num_bold=1,
+):
     """
     This workflow controls the functional preprocessing stages of FMRIPREP.
 
@@ -61,95 +79,92 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         :simple_form: yes
 
         from fmriprep.workflows.bold import init_func_preproc_wf
-        from collections import namedtuple
+        from collections import namedtuple, OrderedDict
         BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
-        wf = init_func_preproc_wf('/completely/made/up/path/sub-01_task-nback_bold.nii.gz',
-                                  omp_nthreads=1,
-                                  ignore=[],
-                                  freesurfer=True,
-                                  reportlets_dir='.',
-                                  output_dir='.',
-                                  template='MNI152NLin2009cAsym',
-                                  output_spaces=['T1w', 'fsnative',
-                                                 'template', 'fsaverage5'],
-                                  debug=False,
-                                  use_bbr=True,
-                                  t2s_coreg=False,
-                                  bold2t1w_dof=9,
-                                  fmap_bspline=True,
-                                  fmap_demean=True,
-                                  use_syn=True,
-                                  force_syn=True,
-                                  low_mem=False,
-                                  template_out_grid='native',
-                                  medial_surface_nan=False,
-                                  cifti_output=False,
-                                  use_aroma=False,
-                                  err_on_aroma_warn=False,
-                                  aroma_melodic_dim=-200,
-                                  num_bold=1,
-                                  layout=BIDSLayout())
+        wf = init_func_preproc_wf(
+            aroma_melodic_dim=-200,
+            bold2t1w_dof=9,
+            bold_file='/completely/made/up/path/sub-01_task-nback_bold.nii.gz',
+            cifti_output=False,
+            debug=False,
+            err_on_aroma_warn=False,
+            fmap_bspline=True,
+            fmap_demean=True,
+            force_syn=True,
+            freesurfer=True,
+            ignore=[],
+            low_mem=False,
+            medial_surface_nan=False,
+            omp_nthreads=1,
+            output_dir='.',
+            output_spaces=OrderedDict([
+                ('MNI152Lin', {}), ('fsaverage', {'density': '10k'}),
+                ('T1w', {}), ('fsnative', {})]),
+            reportlets_dir='.',
+            t2s_coreg=False,
+            use_aroma=False,
+            use_bbr=True,
+            use_syn=True,
+            layout=BIDSLayout(),
+            num_bold=1,
+        )
 
     **Parameters**
 
+        aroma_melodic_dim : int
+            Maximum number of components identified by MELODIC within ICA-AROMA
+            (default is -200, ie. no limitation).
+        bold2t1w_dof : 6, 9 or 12
+            Degrees-of-freedom for BOLD-T1w registration
         bold_file : str
             BOLD series NIfTI file
-        ignore : list
-            Preprocessing steps to skip (may include "slicetiming", "fieldmaps")
+        cifti_output : bool
+            Generate bold CIFTI file in output spaces
+        debug : bool
+            Enable debugging outputs
+        err_on_aroma_warn : bool
+            Do not crash on ICA-AROMA errors
+        fmap_bspline : bool
+            **Experimental**: Fit B-Spline field using least-squares
+        fmap_demean : bool
+            Demean voxel-shift map during unwarp
+        force_syn : bool
+            **Temporary**: Always run SyN-based SDC
         freesurfer : bool
             Enable FreeSurfer functional registration (bbregister) and resampling
             BOLD series to FreeSurfer surface meshes.
+        ignore : list
+            Preprocessing steps to skip (may include "slicetiming", "fieldmaps")
+        low_mem : bool
+            Write uncompressed .nii files in some cases to reduce memory usage
+        medial_surface_nan : bool
+            Replace medial wall values with NaNs on functional GIFTI files
+        omp_nthreads : int
+            Maximum number of threads an individual process may use
+        output_dir : str
+            Directory in which to save derivatives
+        output_spaces : OrderedDict
+            Ordered dictionary where keys are TemplateFlow ID strings (e.g. ``MNI152Lin``,
+            ``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, or ``fsLR``) strings designating
+            nonstandard references (e.g. ``T1w`` or ``anat``, ``sbref``, ``run``, etc.),
+            or paths pointing to custom templates organized in a TemplateFlow-like structure.
+            Values of the dictionary aggregate modifiers (e.g. the value for the key ``MNI152Lin``
+            could be ``{'resolution': 2}`` if one wants the resampling to be done on the 2mm
+            resolution version of the selected template).
+        reportlets_dir : str
+            Absolute path of a directory in which reportlets will be temporarily stored
+        t2s_coreg : bool
+            For multiecho EPI, use the calculated T2*-map for T2*-driven coregistration
+        use_aroma : bool
+            Perform ICA-AROMA on MNI-resampled functional series
         use_bbr : bool or None
             Enable/disable boundary-based registration refinement.
             If ``None``, test BBR result for distortion before accepting.
             When using ``t2s_coreg``, BBR will be enabled by default unless
             explicitly specified otherwise.
-        t2s_coreg : bool
-            For multiecho EPI, use the calculated T2*-map for T2*-driven coregistration
-        bold2t1w_dof : 6, 9 or 12
-            Degrees-of-freedom for BOLD-T1w registration
-        reportlets_dir : str
-            Directory in which to save reportlets
-        output_spaces : list
-            List of output spaces functional images are to be resampled to.
-            Some parts of pipeline will only be instantiated for some output spaces.
-
-            Valid spaces:
-
-                - T1w
-                - template
-                - fsnative
-                - fsaverage (or other pre-existing FreeSurfer templates)
-        template : str
-            Name of template targeted by ``template`` output space
-        output_dir : str
-            Directory in which to save derivatives
-        omp_nthreads : int
-            Maximum number of threads an individual process may use
-        fmap_bspline : bool
-            **Experimental**: Fit B-Spline field using least-squares
-        fmap_demean : bool
-            Demean voxel-shift map during unwarp
         use_syn : bool
             **Experimental**: Enable ANTs SyN-based susceptibility distortion correction (SDC).
             If fieldmaps are present and enabled, this is not run, by default.
-        force_syn : bool
-            **Temporary**: Always run SyN-based SDC
-        use_aroma : bool
-            Perform ICA-AROMA on MNI-resampled functional series
-        err_on_aroma_warn : bool
-            Do not fail on ICA-AROMA errors
-        medial_surface_nan : bool
-            Replace medial wall values with NaNs on functional GIFTI files
-        cifti_output : bool
-            Generate bold CIFTI file in output spaces
-        debug : bool
-            Enable debugging outputs
-        low_mem : bool
-            Write uncompressed .nii files in some cases to reduce memory usage
-        template_out_grid : str
-            Keyword ('native', '1mm' or '2mm') or path of custom reference
-            image for normalization
         layout : BIDSLayout
             BIDSLayout structure to enable metadata retrieval
         num_bold : int
@@ -171,9 +186,9 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
             gray-matter (GM), white-matter (WM) and cerebrospinal fluid (CSF)
         t1_tpms
             List of tissue probability maps in T1w space
-        t1_2_mni_forward_transform
+        anat2std_xfm
             ANTs-compatible affine-and-warp transform file
-        t1_2_mni_reverse_transform
+        std2anat_xfm
             ANTs-compatible affine-and-warp transform file (inverse)
         subjects_dir
             FreeSurfer SUBJECTS_DIR
@@ -191,9 +206,9 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
             BOLD series, resampled to T1w space
         bold_mask_t1
             BOLD series mask in T1w space
-        bold_mni
+        bold_std
             BOLD series, resampled to template space
-        bold_mask_mni
+        bold_mask_std
             BOLD series mask in template space
         confounds
             TSV of confounds
@@ -219,7 +234,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         * :py:func:`~fmriprep.workflows.bold.registration.init_bold_reg_wf`
         * :py:func:`~fmriprep.workflows.bold.confounds.init_bold_confounds_wf`
         * :py:func:`~fmriprep.workflows.bold.confounds.init_ica_aroma_wf`
-        * :py:func:`~fmriprep.workflows.bold.resampling.init_bold_mni_trans_wf`
+        * :py:func:`~fmriprep.workflows.bold.resampling.init_bold_std_trans_wf`
         * :py:func:`~fmriprep.workflows.bold.resampling.init_bold_preproc_trans_wf`
         * :py:func:`~fmriprep.workflows.bold.resampling.init_bold_surf_wf`
         * :py:func:`~fmriprep.workflows.fieldmap.pepolar.init_pepolar_unwarp_wf`
@@ -228,8 +243,17 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         * :py:func:`~fmriprep.workflows.fieldmap.init_nonlinear_sdc_wf`
 
     """
+    from .resampling import NONSTANDARD_REFERENCES
     from ..fieldmap.base import init_sdc_wf  # Avoid circular dependency (#1066)
 
+    # Filter out standard spaces to a separate dict
+    std_spaces = OrderedDict([
+        (key, modifiers) for key, modifiers in output_spaces.items()
+        if key not in NONSTANDARD_REFERENCES])
+    volume_std_spaces = OrderedDict([
+        (key, modifiers) for key, modifiers in std_spaces.items()
+        if not key.startswith('fs')])
+
     ref_file = bold_file
     mem_gb = {'filesize': 1, 'resampled': 1, 'largemem': 1}
     bold_tlen = 10
@@ -329,7 +353,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
 All resamplings can be performed with *a single interpolation
 step* by composing all the pertinent transformations (i.e. head-motion
 transform matrices, susceptibility distortion correction when available,
-and co-registrations to anatomical and template spaces).
+and co-registrations to anatomical and output spaces).
 Gridded (volumetric) resamplings were performed using `antsApplyTransforms` (ANTs),
 configured with Lanczos interpolation to minimize the smoothing
 effects of other kernels [@lanczos].
@@ -341,7 +365,8 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         fields=['bold_file', 'subjects_dir', 'subject_id',
                 't1_preproc', 't1_brain', 't1_mask', 't1_seg', 't1_tpms',
                 't1_aseg', 't1_aparc',
-                't1_2_mni_forward_transform', 't1_2_mni_reverse_transform',
+                'anat2std_xfm', 'std2anat_xfm', 'template',
+                'joint_anat2std_xfm', 'joint_std2anat_xfm', 'joint_template',
                 't1_2_fsnative_forward_transform', 't1_2_fsnative_reverse_transform']),
         name='inputnode')
     inputnode.inputs.bold_file = bold_file
@@ -351,7 +376,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
 
     outputnode = pe.Node(niu.IdentityInterface(
         fields=['bold_t1', 'bold_t1_ref', 'bold_mask_t1', 'bold_aseg_t1', 'bold_aparc_t1',
-                'bold_mni', 'bold_mni_ref' 'bold_mask_mni', 'bold_aseg_mni', 'bold_aparc_mni',
+                'bold_std', 'bold_std_ref' 'bold_mask_std', 'bold_aseg_std', 'bold_aparc_std',
                 'bold_cifti', 'cifti_variant', 'cifti_variant_key', 'confounds', 'surfaces',
                 'aroma_noise_ics', 'melodic_mix', 'nonaggr_denoised_file']),
         name='outputnode')
@@ -361,7 +386,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
     boldbuffer = pe.Node(niu.IdentityInterface(fields=['bold_file']), name='boldbuffer')
 
     summary = pe.Node(
-        FunctionalSummary(output_spaces=output_spaces,
+        FunctionalSummary(output_spaces=list(output_spaces.keys()),
                           slice_timing=run_stc,
                           registration='FreeSurfer' if freesurfer else 'FSL',
                           registration_dof=bold2t1w_dof,
@@ -370,7 +395,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         name='summary', mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
 
     # CIfTI output: currently, we only support fsaverage{5,6}
-    cifti_spaces = [s for s in output_spaces if s in ('fsaverage5', 'fsaverage6')]
+    cifti_spaces = [s for s in output_spaces.keys() if s in ('fsaverage5', 'fsaverage6')]
     cifti_output = cifti_output and cifti_spaces
     func_derivatives_wf = init_func_derivatives_wf(
         bids_root=layout.root,
@@ -379,11 +404,13 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         metadata=metadata,
         output_dir=output_dir,
         output_spaces=output_spaces,
-        template=template,
+        standard_spaces=list(std_spaces.keys()),
         use_aroma=use_aroma,
     )
 
     workflow.connect([
+        (inputnode, func_derivatives_wf, [
+            ('template', 'inputnode.template')]),
         (outputnode, func_derivatives_wf, [
             ('bold_t1', 'inputnode.bold_t1'),
             ('bold_t1_ref', 'inputnode.bold_t1_ref'),
@@ -401,19 +428,6 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         ]),
     ])
 
-    if 'template' in output_spaces:
-        # Artifacts resampled in MNI space can only be sinked if they
-        # were actually generated. See #1348.
-        workflow.connect([
-            (outputnode, func_derivatives_wf, [
-                ('bold_mni_ref', 'inputnode.bold_mni_ref'),
-                ('bold_mni', 'inputnode.bold_mni'),
-                ('bold_aseg_mni', 'inputnode.bold_aseg_mni'),
-                ('bold_aparc_mni', 'inputnode.bold_aparc_mni'),
-                ('bold_mask_mni', 'inputnode.bold_mask_mni'),
-            ]),
-        ])
-
     # Generate a tentative boldref
     bold_reference_wf = init_bold_reference_wf(omp_nthreads=omp_nthreads)
     if sbref_file is not None:
@@ -495,7 +509,8 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
     bold_sdc_wf = init_sdc_wf(
         fmaps, metadata, omp_nthreads=omp_nthreads,
         debug=debug, fmap_demean=fmap_demean, fmap_bspline=fmap_bspline)
-    bold_sdc_wf.inputs.inputnode.template = template
+    bold_sdc_wf.inputs.inputnode.template = 'MNI152NLin2009cAsym' \
+        if 'MNI152NLin2009cAsym' in volume_std_spaces else next(iter(volume_std_spaces))
 
     if not fmaps:
         LOGGER.warning('SDC: no fieldmaps found or they were ignored (%s).',
@@ -570,8 +585,9 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
         (bold_reg_wf, summary, [('outputnode.fallback', 'fallback')]),
         # SDC (or pass-through workflow)
         (inputnode, bold_sdc_wf, [
-            ('t1_brain', 'inputnode.t1_brain'),
-            ('t1_2_mni_reverse_transform', 'inputnode.t1_2_mni_reverse_transform')]),
+            ('joint_template', 'inputnode.templates'),
+            ('joint_std2anat_xfm', 'inputnode.std2anat_xfm')]),
+        (inputnode, bold_sdc_wf, [('t1_brain', 'inputnode.t1_brain')]),
         (bold_reference_wf, bold_sdc_wf, [
             ('outputnode.ref_image', 'inputnode.bold_ref'),
             ('outputnode.ref_image_brain', 'inputnode.bold_ref_brain'),
@@ -636,11 +652,8 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
 
     if fmaps:
         from ..fieldmap.unwarp import init_fmap_unwarp_report_wf
-        sdc_type = fmaps[0]['suffix']
-
         # Report on BOLD correction
-        fmap_unwarp_report_wf = init_fmap_unwarp_report_wf(
-            suffix='sdc_%s' % sdc_type)
+        fmap_unwarp_report_wf = init_fmap_unwarp_report_wf()
         workflow.connect([
             (inputnode, fmap_unwarp_report_wf, [
                 ('t1_seg', 'inputnode.in_seg')]),
@@ -652,7 +665,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
                 ('outputnode.bold_ref', 'inputnode.in_post')]),
         ])
 
-        if force_syn and sdc_type != 'syn':
+        if force_syn and fmaps[0]['suffix'] != 'syn':
             syn_unwarp_report_wf = init_fmap_unwarp_report_wf(
                 suffix='forcedsyn', name='syn_unwarp_report_wf')
             workflow.connect([
@@ -667,7 +680,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
             ])
 
     # Map final BOLD mask into T1w space (if required)
-    if 'T1w' in output_spaces:
+    if 'T1w' in output_spaces or 'anat' in output_spaces:
         from niworkflows.interfaces.fixes import (
             FixHeaderApplyTransforms as ApplyTransforms
         )
@@ -687,57 +700,60 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
                 ('output_image', 'bold_mask_t1')]),
         ])
 
-    if 'template' in output_spaces:
+    if volume_std_spaces:
         # Apply transforms in 1 shot
         # Only use uncompressed output if AROMA is to be run
-        bold_mni_trans_wf = init_bold_mni_trans_wf(
-            template=template,
-            freesurfer=freesurfer,
+        bold_std_trans_wf = init_bold_std_trans_wf(
+            standard_spaces=std_spaces,
             mem_gb=mem_gb['resampled'],
             omp_nthreads=omp_nthreads,
-            template_out_grid=template_out_grid,
             use_compression=not low_mem,
             use_fieldwarp=fmaps is not None,
-            name='bold_mni_trans_wf'
+            name='bold_std_trans_wf'
         )
-        carpetplot_wf = init_carpetplot_wf(
-            mem_gb=mem_gb['resampled'],
-            metadata=metadata,
-            name='carpetplot_wf')
-
         workflow.connect([
-            (inputnode, bold_mni_trans_wf, [
+            (inputnode, bold_std_trans_wf, [
+                ('joint_template', 'inputnode.templates'),
+                ('joint_anat2std_xfm', 'inputnode.anat2std_xfm'),
                 ('bold_file', 'inputnode.name_source'),
-                ('t1_2_mni_forward_transform', 'inputnode.t1_2_mni_forward_transform'),
                 ('t1_aseg', 'inputnode.bold_aseg'),
                 ('t1_aparc', 'inputnode.bold_aparc')]),
-            (bold_hmc_wf, bold_mni_trans_wf, [
+            (bold_hmc_wf, bold_std_trans_wf, [
                 ('outputnode.xforms', 'inputnode.hmc_xforms')]),
-            (bold_reg_wf, bold_mni_trans_wf, [
+            (bold_reg_wf, bold_std_trans_wf, [
                 ('outputnode.itk_bold_to_t1', 'inputnode.itk_bold_to_t1')]),
-            (bold_bold_trans_wf if not multiecho else bold_t2s_wf, bold_mni_trans_wf, [
+            (bold_bold_trans_wf if not multiecho else bold_t2s_wf, bold_std_trans_wf, [
                 ('outputnode.bold_mask', 'inputnode.bold_mask')]),
-            (bold_sdc_wf, bold_mni_trans_wf, [
+            (bold_sdc_wf, bold_std_trans_wf, [
                 ('outputnode.out_warp', 'inputnode.fieldwarp')]),
-            (bold_mni_trans_wf, outputnode, [('outputnode.bold_mni', 'bold_mni'),
-                                             ('outputnode.bold_mni_ref', 'bold_mni_ref'),
-                                             ('outputnode.bold_mask_mni', 'bold_mask_mni'),
-                                             ('outputnode.bold_aseg_mni', 'bold_aseg_mni'),
-                                             ('outputnode.bold_aparc_mni', 'bold_aparc_mni')]),
-            (inputnode, carpetplot_wf, [
-                ('t1_2_mni_reverse_transform', 'inputnode.t1_2_mni_reverse_transform')]),
-            (bold_bold_trans_wf if not multiecho else bold_t2s_wf, carpetplot_wf, [
-                ('outputnode.bold', 'inputnode.bold'),
-                ('outputnode.bold_mask', 'inputnode.bold_mask')]),
-            (bold_reg_wf, carpetplot_wf, [
-                ('outputnode.itk_t1_to_bold', 'inputnode.t1_bold_xform')]),
-            (bold_confounds_wf, carpetplot_wf, [
-                ('outputnode.confounds_file', 'inputnode.confounds_file')]),
+            (bold_std_trans_wf, outputnode, [('outputnode.bold_std', 'bold_std'),
+                                             ('outputnode.bold_std_ref', 'bold_std_ref'),
+                                             ('outputnode.bold_mask_std', 'bold_mask_std'),
+                                             ('outputnode.bold_aseg_std', 'bold_aseg_std'),
+                                             ('outputnode.bold_aparc_std', 'bold_aparc_std')]),
         ])
 
+        if 'MNI152NLin2009cAsym' in std_spaces:
+            carpetplot_wf = init_carpetplot_wf(
+                standard_spaces=std_spaces,
+                mem_gb=mem_gb['resampled'],
+                metadata=metadata,
+                name='carpetplot_wf')
+            workflow.connect([
+                (inputnode, carpetplot_wf, [
+                    ('joint_std2anat_xfm', 'inputnode.std2anat_xfm')]),
+                (bold_bold_trans_wf if not multiecho else bold_t2s_wf, carpetplot_wf, [
+                    ('outputnode.bold', 'inputnode.bold'),
+                    ('outputnode.bold_mask', 'inputnode.bold_mask')]),
+                (bold_reg_wf, carpetplot_wf, [
+                    ('outputnode.itk_t1_to_bold', 'inputnode.t1_bold_xform')]),
+                (bold_confounds_wf, carpetplot_wf, [
+                    ('outputnode.confounds_file', 'inputnode.confounds_file')]),
+            ])
+
         if not multiecho:
             workflow.connect([
-                (bold_split, bold_mni_trans_wf, [
+                (bold_split, bold_std_trans_wf, [
                     ('out_files', 'inputnode.bold_split')])
             ])
         else:
@@ -745,18 +761,28 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
             workflow.connect([
                 (bold_t2s_wf, split_opt_comb, [
                     ('outputnode.bold', 'in_file')]),
-                (split_opt_comb, bold_mni_trans_wf, [
+                (split_opt_comb, bold_std_trans_wf, [
                     ('out_files', 'inputnode.bold_split')
                 ])
             ])
 
-        if use_aroma:
-            # ICA-AROMA workflow
-            # Internally resamples to MNI152 Linear (2006)
+        # Artifacts resampled in MNI space can only be sinked if they
+        # were actually generated. See #1348.
+        # Uses the parameterized outputnode to generate all outputs
+        workflow.connect([
+            (bold_std_trans_wf, func_derivatives_wf, [
+                ('poutputnode.bold_std_ref', 'inputnode.bold_std_ref'),
+                ('poutputnode.bold_std', 'inputnode.bold_std'),
+                ('poutputnode.bold_aseg_std', 'inputnode.bold_aseg_std'),
+                ('poutputnode.bold_aparc_std', 'inputnode.bold_aparc_std'),
+                ('poutputnode.bold_mask_std', 'inputnode.bold_mask_std'),
+            ]),
+        ])
+
+        if use_aroma and 'MNI152NLin6Asym' in std_spaces:  # ICA-AROMA workflow
             from .confounds import init_ica_aroma_wf
 
             ica_aroma_wf = init_ica_aroma_wf(
-                template=template,
                 metadata=metadata,
                 mem_gb=mem_gb['resampled'],
                 omp_nthreads=omp_nthreads,
@@ -775,20 +801,14 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
                 ]),
             ])
             workflow.connect([
+                (bold_std_trans_wf, ica_aroma_wf, [
+                    ('outputnode.bold_std', 'inputnode.bold_std'),
+                    ('outputnode.bold_mask_std', 'inputnode.bold_mask_std'),
+                    ('outputnode.templates', 'inputnode.templates')]),
                 (inputnode, ica_aroma_wf, [
-                    ('bold_file', 'inputnode.name_source'),
-                    ('t1_2_mni_forward_transform', 'inputnode.t1_2_mni_forward_transform')]),
-                (bold_split, ica_aroma_wf, [
-                    ('out_files', 'inputnode.bold_split')]),
+                    ('bold_file', 'inputnode.name_source')]),
                 (bold_hmc_wf, ica_aroma_wf, [
-                    ('outputnode.movpar_file', 'inputnode.movpar_file'),
-                    ('outputnode.xforms', 'inputnode.hmc_xforms')]),
-                (bold_reg_wf, ica_aroma_wf, [
-                    ('outputnode.itk_bold_to_t1', 'inputnode.itk_bold_to_t1')]),
-                (bold_bold_trans_wf if not multiecho else bold_t2s_wf, ica_aroma_wf, [
-                    ('outputnode.bold_mask', 'inputnode.bold_mask')]),
-                (bold_sdc_wf, ica_aroma_wf, [
-                    ('outputnode.out_warp', 'inputnode.fieldwarp')]),
+                    ('outputnode.movpar_file', 'inputnode.movpar_file')]),
                 (bold_reference_wf, ica_aroma_wf, [
                     ('outputnode.skip_vols', 'inputnode.skip_vols')]),
                 (bold_confounds_wf, join, [
@@ -803,7 +823,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
             ])
 
     # SURFACES ##################################################################################
-    surface_spaces = [space for space in output_spaces if space.startswith('fs')]
+    surface_spaces = [space for space in output_spaces.keys() if space.startswith('fs')]
     if freesurfer and surface_spaces:
         LOGGER.log(25, 'Creating BOLD surface-sampling workflow.')
         bold_surf_wf = init_bold_surf_wf(mem_gb=mem_gb['resampled'],
@@ -834,7 +854,7 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
                 (bold_surf_wf, gen_cifti, [
                     ('outputnode.surfaces', 'gifti_files')]),
                 (inputnode, gen_cifti, [('subjects_dir', 'subjects_dir')]),
-                (bold_mni_trans_wf, gen_cifti, [('outputnode.bold_mni', 'bold_file')]),
+                (bold_std_trans_wf, gen_cifti, [('outputnode.bold_std', 'bold_file')]),
                 (gen_cifti, outputnode, [('out_file', 'bold_cifti'),
                                          ('variant', 'cifti_variant'),
                                          ('variant_key', 'cifti_variant_key')]),
@@ -842,13 +862,13 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
 
     # REPORTING ############################################################
     ds_report_summary = pe.Node(
-        DerivativesDataSink(suffix='summary'),
+        DerivativesDataSink(desc='summary', keep_dtype=True),
         name='ds_report_summary', run_without_submitting=True,
         mem_gb=DEFAULT_MEMORY_MIN_GB)
 
     ds_report_validation = pe.Node(
         DerivativesDataSink(base_directory=reportlets_dir,
-                            suffix='validation'),
+                            desc='validation', keep_dtype=True),
         name='ds_report_validation', run_without_submitting=True,
         mem_gb=DEFAULT_MEMORY_MIN_GB)
 
@@ -867,195 +887,6 @@ def init_func_preproc_wf(bold_file, ignore, freesurfer,
     return workflow
 
 
-def init_func_derivatives_wf(bids_root, cifti_output, freesurfer,
-                             metadata, output_dir, output_spaces,
-                             template, use_aroma,
-                             name='func_derivatives_wf'):
-    """
-    Set up a battery of datasinks to store derivatives in the right location
-    """
-    from smriprep.workflows.outputs import _bids_relative
-    workflow = Workflow(name=name)
-
-    inputnode = pe.Node(
-        niu.IdentityInterface(
-            fields=['source_file',
-                    'bold_t1', 'bold_t1_ref', 'bold_mask_t1',
-                    'bold_mni', 'bold_mni_ref', 'bold_mask_mni',
-                    'bold_aseg_t1', 'bold_aparc_t1', 'bold_aseg_mni',
-                    'bold_aparc_mni', 'cifti_variant_key',
-                    'confounds', 'surfaces', 'aroma_noise_ics', 'melodic_mix',
-                    'nonaggr_denoised_file', 'bold_cifti', 'cifti_variant']),
-        name='inputnode')
-
-    raw_sources = pe.Node(niu.Function(function=_bids_relative), name='raw_sources')
-    raw_sources.inputs.bids_root = bids_root
-
-    ds_confounds = pe.Node(DerivativesDataSink(
-        base_directory=output_dir, desc='confounds', suffix='regressors'),
-        name="ds_confounds", run_without_submitting=True,
-        mem_gb=DEFAULT_MEMORY_MIN_GB)
-    workflow.connect([
-        (inputnode, raw_sources, [('source_file', 'in_files')]),
-        (inputnode, ds_confounds, [('source_file', 'source_file'),
-                                   ('confounds', 'in_file')]),
-    ])
-
-    # Resample to T1w space
-    if 'T1w' in output_spaces:
-        ds_bold_t1 = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space='T1w', desc='preproc',
-                                keep_dtype=True, compress=True, SkullStripped=False,
-                                RepetitionTime=metadata.get('RepetitionTime')),
-            name='ds_bold_t1', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        ds_bold_t1_ref = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space='T1w', suffix='boldref'),
-            name='ds_bold_t1_ref', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-
-        ds_bold_mask_t1 = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space='T1w', desc='brain',
-                                suffix='mask'),
-            name='ds_bold_mask_t1', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        workflow.connect([
-            (inputnode, ds_bold_t1, [('source_file', 'source_file'),
-                                     ('bold_t1', 'in_file')]),
-            (inputnode, ds_bold_t1_ref, [('source_file', 'source_file'),
-                                         ('bold_t1_ref', 'in_file')]),
-            (inputnode, ds_bold_mask_t1, [('source_file', 'source_file'),
-                                          ('bold_mask_t1', 'in_file')]),
-            (raw_sources, ds_bold_mask_t1, [('out', 'RawSources')]),
-        ])
-        if freesurfer:
-            ds_bold_aseg_t1 = pe.Node(DerivativesDataSink(
-                base_directory=output_dir, space='T1w', desc='aseg', suffix='dseg'),
-                name='ds_bold_aseg_t1', run_without_submitting=True,
-                mem_gb=DEFAULT_MEMORY_MIN_GB)
-            ds_bold_aparc_t1 = pe.Node(DerivativesDataSink(
-                base_directory=output_dir, space='T1w', desc='aparcaseg', suffix='dseg'),
-                name='ds_bold_aparc_t1', run_without_submitting=True,
-                mem_gb=DEFAULT_MEMORY_MIN_GB)
-            workflow.connect([
-                (inputnode, ds_bold_aseg_t1, [('source_file', 'source_file'),
-                                              ('bold_aseg_t1', 'in_file')]),
-                (inputnode, ds_bold_aparc_t1, [('source_file', 'source_file'),
-                                               ('bold_aparc_t1', 'in_file')]),
-            ])
-
-    # Resample to template (default: MNI)
-    if 'template' in output_spaces:
-        ds_bold_mni = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space=template, desc='preproc',
-                                keep_dtype=True, compress=True, SkullStripped=False,
-                                RepetitionTime=metadata.get('RepetitionTime')),
-            name='ds_bold_mni', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        ds_bold_mni_ref = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space=template, suffix='boldref'),
-            name='ds_bold_mni_ref', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-
-        ds_bold_mask_mni = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space=template, desc='brain',
-                                suffix='mask'),
-            name='ds_bold_mask_mni', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        workflow.connect([
-            (inputnode, ds_bold_mni, [('source_file', 'source_file'),
-                                      ('bold_mni', 'in_file')]),
-            (inputnode, ds_bold_mni_ref, [('source_file', 'source_file'),
-                                          ('bold_mni_ref', 'in_file')]),
-            (inputnode, ds_bold_mask_mni, [('source_file', 'source_file'),
-                                           ('bold_mask_mni', 'in_file')]),
-            (raw_sources, ds_bold_mask_mni, [('out', 'RawSources')]),
-        ])
-
-        if freesurfer:
-            ds_bold_aseg_mni = pe.Node(DerivativesDataSink(
-                base_directory=output_dir, space=template, desc='aseg', suffix='dseg'),
-                name='ds_bold_aseg_mni', run_without_submitting=True,
-                mem_gb=DEFAULT_MEMORY_MIN_GB)
-            ds_bold_aparc_mni = pe.Node(DerivativesDataSink(
-                base_directory=output_dir, space=template, desc='aparcaseg', suffix='dseg'),
-                name='ds_bold_aparc_mni', run_without_submitting=True,
-                mem_gb=DEFAULT_MEMORY_MIN_GB)
-            workflow.connect([
-                (inputnode, ds_bold_aseg_mni, [('source_file', 'source_file'),
-                                               ('bold_aseg_mni', 'in_file')]),
-                (inputnode, ds_bold_aparc_mni, [('source_file', 'source_file'),
-                                                ('bold_aparc_mni', 'in_file')]),
-            ])
-
-    # fsaverage space
-    if freesurfer and any(space.startswith('fs') for space in output_spaces):
-        name_surfs = pe.MapNode(GiftiNameSource(
-            pattern=r'(?P<LR>[lr])h.(?P<space>\w+).gii', template='space-{space}_hemi-{LR}.func'),
-            iterfield='in_file', name='name_surfs', mem_gb=DEFAULT_MEMORY_MIN_GB,
-            run_without_submitting=True)
-        ds_bold_surfs = pe.MapNode(DerivativesDataSink(base_directory=output_dir),
-                                   iterfield=['in_file', 'suffix'], name='ds_bold_surfs',
-                                   run_without_submitting=True,
-                                   mem_gb=DEFAULT_MEMORY_MIN_GB)
-
-        workflow.connect([
-            (inputnode, name_surfs, [('surfaces', 'in_file')]),
-            (inputnode, ds_bold_surfs, [('source_file', 'source_file'),
-                                        ('surfaces', 'in_file')]),
-            (name_surfs, ds_bold_surfs, [('out_name', 'suffix')]),
-        ])
-
-        # CIFTI output
-        if cifti_output and 'template' in output_spaces:
-            name_cifti = pe.MapNode(
-                CiftiNameSource(), iterfield=['variant'], name='name_cifti',
-                mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
-            cifti_bolds = pe.MapNode(
-                DerivativesDataSink(base_directory=output_dir, compress=False),
-                iterfield=['in_file', 'suffix'], name='cifti_bolds',
-                run_without_submitting=True, mem_gb=DEFAULT_MEMORY_MIN_GB)
-            cifti_key = pe.MapNode(DerivativesDataSink(
-                base_directory=output_dir), iterfield=['in_file', 'suffix'],
-                name='cifti_key', run_without_submitting=True,
-                mem_gb=DEFAULT_MEMORY_MIN_GB)
-            workflow.connect([
-                (inputnode, name_cifti, [('cifti_variant', 'variant')]),
-                (inputnode, cifti_bolds, [('bold_cifti', 'in_file'),
-                                          ('source_file', 'source_file')]),
-                (name_cifti, cifti_bolds, [('out_name', 'suffix')]),
-                (name_cifti, cifti_key, [('out_name', 'suffix')]),
-                (inputnode, cifti_key, [('source_file', 'source_file'),
-                                        ('cifti_variant_key', 'in_file')]),
-            ])
-
-    if use_aroma:
-        ds_aroma_noise_ics = pe.Node(DerivativesDataSink(
-            base_directory=output_dir, suffix='AROMAnoiseICs'),
-            name="ds_aroma_noise_ics", run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        ds_melodic_mix = pe.Node(DerivativesDataSink(
-            base_directory=output_dir, desc='MELODIC', suffix='mixing'),
-            name="ds_melodic_mix", run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-        ds_aroma_mni = pe.Node(
-            DerivativesDataSink(base_directory=output_dir, space=template,
-                                desc='smoothAROMAnonaggr', keep_dtype=True),
-            name='ds_aroma_mni', run_without_submitting=True,
-            mem_gb=DEFAULT_MEMORY_MIN_GB)
-
-        workflow.connect([
-            (inputnode, ds_aroma_noise_ics, [('source_file', 'source_file'),
-                                             ('aroma_noise_ics', 'in_file')]),
-            (inputnode, ds_melodic_mix, [('source_file', 'source_file'),
-                                         ('melodic_mix', 'in_file')]),
-            (inputnode, ds_aroma_mni, [('source_file', 'source_file'),
-                                       ('nonaggr_denoised_file', 'in_file')]),
-        ])
-
-    return workflow
-
-
 def _get_series_len(bold_fname):
     from niworkflows.interfaces.registration import _get_vols_to_discard
     img = nb.load(bold_fname)
diff --git a/fmriprep/workflows/bold/confounds.py b/fmriprep/workflows/bold/confounds.py
index 16b973492..3ec068e27 100755
--- a/fmriprep/workflows/bold/confounds.py
+++ b/fmriprep/workflows/bold/confounds.py
@@ -18,6 +18,7 @@
 from niworkflows.interfaces.fixes import FixHeaderApplyTransforms as ApplyTransforms
 from niworkflows.interfaces.images import SignalExtraction
 from niworkflows.interfaces.masks import ROIsPlot
+from niworkflows.interfaces.utility import KeySelect
 from niworkflows.interfaces.patches import (
     RobustACompCor as ACompCor,
     RobustTCompCor as TCompCor,
@@ -32,7 +33,7 @@
     FMRISummary, DerivativesDataSink
 )
 
-from .resampling import init_bold_mni_trans_wf
+from .resampling import init_bold_std_trans_wf
 
 DEFAULT_MEMORY_MIN_GB = 0.01
 
@@ -219,7 +220,7 @@ def init_bold_confs_wf(mem_gb, metadata, name="bold_confs_wf"):
                         name='rois_plot', mem_gb=mem_gb)
 
     ds_report_bold_rois = pe.Node(
-        DerivativesDataSink(suffix='rois'),
+        DerivativesDataSink(desc='rois', keep_dtype=True),
         name='ds_report_bold_rois', run_without_submitting=True,
         mem_gb=DEFAULT_MEMORY_MIN_GB)
 
@@ -308,7 +309,7 @@ def _pick_wm(files):
     return workflow
 
 
-def init_carpetplot_wf(mem_gb, metadata, name="bold_carpet_wf"):
+def init_carpetplot_wf(standard_spaces, mem_gb, metadata, name="bold_carpet_wf"):
     """
 
     Resamples the MNI parcellation (ad-hoc parcellation derived from the
@@ -337,7 +338,7 @@ def init_carpetplot_wf(mem_gb, metadata, name="bold_carpet_wf"):
         t1_bold_xform
             Affine matrix that maps the T1w space into alignment with
             the native BOLD space
-        t1_2_mni_reverse_transform
+        std2anat_xfm
             ANTs-compatible affine-and-warp transform file
 
     **Outputs**
@@ -348,12 +349,17 @@ def init_carpetplot_wf(mem_gb, metadata, name="bold_carpet_wf"):
     """
     inputnode = pe.Node(niu.IdentityInterface(
         fields=['bold', 'bold_mask', 'confounds_file',
-                't1_bold_xform', 't1_2_mni_reverse_transform']),
+                't1_bold_xform', 'std2anat_xfm']),
         name='inputnode')
 
     outputnode = pe.Node(niu.IdentityInterface(
         fields=['out_carpetplot']), name='outputnode')
 
+    select_std = pe.Node(KeySelect(
+        keys=list(standard_spaces.keys()), fields=['std2anat_xfm']),
+        name='select_std', run_without_submitting=True)
+    select_std.inputs.key = 'MNI152NLin2009cAsym'
+
     # List transforms
     mrg_xfms = pe.Node(niu.Merge(2), name='mrg_xfms')
 
@@ -377,15 +383,16 @@ def init_carpetplot_wf(mem_gb, metadata, name="bold_carpet_wf"):
             ('framewise_displacement', 'mm', 'FD')]),
         name='conf_plot', mem_gb=mem_gb)
     ds_report_bold_conf = pe.Node(
-        DerivativesDataSink(suffix='carpetplot'),
+        DerivativesDataSink(desc='carpetplot', keep_dtype=True),
         name='ds_report_bold_conf', run_without_submitting=True,
         mem_gb=DEFAULT_MEMORY_MIN_GB)
 
     workflow = Workflow(name=name)
     workflow.connect([
-        (inputnode, mrg_xfms, [('t1_bold_xform', 'in1'),
-                               ('t1_2_mni_reverse_transform', 'in2')]),
+        (inputnode, select_std, [('std2anat_xfm', 'std2anat_xfm')]),
+        (inputnode, mrg_xfms, [('t1_bold_xform', 'in1')]),
         (inputnode, resample_parc, [('bold_mask', 'reference_image')]),
+        (select_std, mrg_xfms, [('std2anat_xfm', 'in2')]),
         (mrg_xfms, resample_parc, [('out', 'transforms')]),
         # Carpetplot
         (inputnode, conf_plot, [
@@ -399,7 +406,7 @@ def init_carpetplot_wf(mem_gb, metadata, name="bold_carpet_wf"):
     return workflow
 
 
-def init_ica_aroma_wf(template, metadata, mem_gb, omp_nthreads,
+def init_ica_aroma_wf(metadata, mem_gb, omp_nthreads,
                       name='ica_aroma_wf',
                       susan_fwhm=6.0,
                       err_on_aroma_warn=False,
@@ -441,7 +448,7 @@ def init_ica_aroma_wf(template, metadata, mem_gb, omp_nthreads,
 
     **Parameters**
 
-        template : str
+        standard_spaces : str
             Spatial normalization template used as target when that
             registration step was previously calculated with
             :py:func:`~fmriprep.workflows.bold.registration.init_bold_reg_wf`.
@@ -454,7 +461,7 @@ def init_ica_aroma_wf(template, metadata, mem_gb, omp_nthreads,
         omp_nthreads : int
             Maximum number of threads an individual process may use
         name : str
-            Name of workflow (default: ``bold_mni_trans_wf``)
+            Name of workflow (default: ``bold_tpl_trans_wf``)
         susan_fwhm : float
             Kernel width (FWHM in mm) for the smoothing step with
             FSL ``susan`` (default: 6.0mm)
@@ -472,7 +479,7 @@ def init_ica_aroma_wf(template, metadata, mem_gb, omp_nthreads,
 
         itk_bold_to_t1
             Affine transform from ``ref_bold_brain`` to T1 space (ITK format)
-        t1_2_mni_forward_transform
+        anat2std_xfm
             ANTs-compatible affine-and-warp transform file
         name_source
             BOLD series NIfTI file
@@ -518,33 +525,22 @@ def init_ica_aroma_wf(template, metadata, mem_gb, omp_nthreads,
 
     inputnode = pe.Node(niu.IdentityInterface(
         fields=[
-            'itk_bold_to_t1',
-            't1_2_mni_forward_transform',
+            'bold_std',
+            'bold_mask_std',
+            'movpar_file',
             'name_source',
             'skip_vols',
-            'bold_split',
-            'bold_mask',
-            'hmc_xforms',
-            'fieldwarp',
-            'movpar_file']), name='inputnode')
+            'templates',
+        ]), name='inputnode')
 
     outputnode = pe.Node(niu.IdentityInterface(
         fields=['aroma_confounds', 'aroma_noise_ics', 'melodic_mix',
                 'nonaggr_denoised_file']), name='outputnode')
 
-    bold_mni_trans_wf = init_bold_mni_trans_wf(
-        template=template,
-        freesurfer=False,
-        mem_gb=mem_gb,
-        omp_nthreads=omp_nthreads,
-        template_out_grid=str(get_template(
-            'MNI152Lin', resolution=2, desc=None, suffix='T1w',
-            extensions=['.nii', '.nii.gz'])),
-        use_compression=False,
-        use_fieldwarp=use_fieldwarp,
-        name='bold_mni_trans_wf'
-    )
-    bold_mni_trans_wf.__desc__ = None
+    select_std = pe.Node(KeySelect(
+        fields=['bold_mask_std', 'bold_std']),
+        name='select_std', run_without_submitting=True)
+    select_std.inputs.key = 'MNI152NLin6Asym'
 
     rm_non_steady_state = pe.Node(niu.Function(function=_remove_volumes,
                                                output_names=['bold_cut']),
@@ -579,7 +575,7 @@ def _getusans_func(image, thresh):
                                             name='ica_aroma_confound_extraction')
 
     ds_report_ica_aroma = pe.Node(
-        DerivativesDataSink(suffix='ica_aroma'),
+        DerivativesDataSink(desc='aroma', keep_dtype=True),
         name='ds_report_ica_aroma', run_without_submitting=True,
         mem_gb=DEFAULT_MEMORY_MIN_GB)
 
@@ -588,21 +584,16 @@ def _getbtthresh(medianval):
 
     # connect the nodes
     workflow.connect([
-        (inputnode, bold_mni_trans_wf, [
-            ('name_source', 'inputnode.name_source'),
-            ('bold_split', 'inputnode.bold_split'),
-            ('bold_mask', 'inputnode.bold_mask'),
-            ('hmc_xforms', 'inputnode.hmc_xforms'),
-            ('itk_bold_to_t1', 'inputnode.itk_bold_to_t1'),
-            ('t1_2_mni_forward_transform', 'inputnode.t1_2_mni_forward_transform'),
-            ('fieldwarp', 'inputnode.fieldwarp')]),
+        (inputnode, select_std, [('templates', 'keys'),
+                                 ('bold_std', 'bold_std'),
+                                 ('bold_mask_std', 'bold_mask_std')]),
         (inputnode, ica_aroma, [('movpar_file', 'motion_parameters')]),
         (inputnode, rm_non_steady_state, [
             ('skip_vols', 'skip_vols')]),
-        (bold_mni_trans_wf, rm_non_steady_state, [
-            ('outputnode.bold_mni', 'bold_file')]),
-        (bold_mni_trans_wf, calc_median_val, [
-            ('outputnode.bold_mask_mni', 'mask_file')]),
+        (select_std, rm_non_steady_state, [
+            ('bold_std', 'bold_file')]),
+        (select_std, calc_median_val, [
+            ('bold_mask_std', 'mask_file')]),
         (rm_non_steady_state, calc_median_val, [
             ('bold_cut', 'in_file')]),
         (rm_non_steady_state, calc_bold_mean, [
@@ -616,13 +607,13 @@ def _getbtthresh(medianval):
         (calc_median_val, smooth, [(('out_stat', _getbtthresh), 'brightness_threshold')]),
         # connect smooth to melodic
         (smooth, melodic, [('smoothed_file', 'in_files')]),
-        (bold_mni_trans_wf, melodic, [
-            ('outputnode.bold_mask_mni', 'mask')]),
+        (select_std, melodic, [
+            ('bold_mask_std', 'mask')]),
         # connect nodes to ICA-AROMA
         (smooth, ica_aroma, [('smoothed_file', 'in_file')]),
-        (bold_mni_trans_wf, ica_aroma, [
-            ('outputnode.bold_mask_mni', 'report_mask'),
-            ('outputnode.bold_mask_mni', 'mask')]),
+        (select_std, ica_aroma, [
+            ('bold_mask_std', 'report_mask'),
+            ('bold_mask_std', 'mask')]),
         (melodic, ica_aroma, [('out_dir', 'melodic_dir')]),
         # generate tsvs from ICA-AROMA
         (ica_aroma, ica_aroma_confound_extraction, [('out_dir', 'in_directory')]),
@@ -632,11 +623,10 @@ def _getbtthresh(medianval):
         (ica_aroma_confound_extraction, outputnode, [('aroma_confounds', 'aroma_confounds'),
                                                      ('aroma_noise_ics', 'aroma_noise_ics'),
                                                      ('melodic_mix', 'melodic_mix')]),
-        # TODO change melodic report to reflect noise and non-noise components
         (ica_aroma, add_non_steady_state, [
             ('nonaggr_denoised_file', 'bold_cut_file')]),
-        (bold_mni_trans_wf, add_non_steady_state, [
-            ('outputnode.bold_mni', 'bold_file')]),
+        (select_std, add_non_steady_state, [
+            ('bold_std', 'bold_file')]),
         (inputnode, add_non_steady_state, [
             ('skip_vols', 'skip_vols')]),
         (add_non_steady_state, outputnode, [('bold_add', 'nonaggr_denoised_file')]),
diff --git a/fmriprep/workflows/bold/outputs.py b/fmriprep/workflows/bold/outputs.py
new file mode 100644
index 000000000..546587c0a
--- /dev/null
+++ b/fmriprep/workflows/bold/outputs.py
@@ -0,0 +1,226 @@
+
+from nipype.pipeline import engine as pe
+from nipype.interfaces import utility as niu
+
+from niworkflows.engine.workflows import LiterateWorkflow as Workflow
+from niworkflows.interfaces.cifti import CiftiNameSource
+from niworkflows.interfaces.surf import GiftiNameSource
+
+from ...interfaces import DerivativesDataSink
+
+
+DEFAULT_MEMORY_MIN_GB = 0.01
+
+
+def init_func_derivatives_wf(
+    bids_root,
+    cifti_output,
+    freesurfer,
+    metadata,
+    output_dir,
+    output_spaces,
+    standard_spaces,
+    use_aroma,
+    name='func_derivatives_wf',
+):
+    """
+    Set up a battery of datasinks to store derivatives in the right location
+
+    **Parameters**
+
+    bids_root : str
+    cifti_output : bool
+    freesurfer : bool
+    metadata : dict
+    output_dir : str
+    output_spaces : OrderedDict
+    use_aroma : bool
+    name : str
+
+    """
+    from smriprep.workflows.outputs import _bids_relative
+    workflow = Workflow(name=name)
+
+    inputnode = pe.Node(
+        niu.IdentityInterface(
+            fields=['template', 'source_file',
+                    'bold_t1', 'bold_t1_ref', 'bold_mask_t1',
+                    'bold_std', 'bold_std_ref', 'bold_mask_std',
+                    'bold_aseg_t1', 'bold_aparc_t1', 'bold_aseg_std',
+                    'bold_aparc_std', 'cifti_variant_key',
+                    'confounds', 'surfaces', 'aroma_noise_ics', 'melodic_mix',
+                    'nonaggr_denoised_file', 'bold_cifti', 'cifti_variant']),
+        name='inputnode')
+
+    raw_sources = pe.Node(niu.Function(function=_bids_relative), name='raw_sources')
+    raw_sources.inputs.bids_root = bids_root
+
+    ds_confounds = pe.Node(DerivativesDataSink(
+        base_directory=output_dir, desc='confounds', suffix='regressors'),
+        name="ds_confounds", run_without_submitting=True,
+        mem_gb=DEFAULT_MEMORY_MIN_GB)
+    workflow.connect([
+        (inputnode, raw_sources, [('source_file', 'in_files')]),
+        (inputnode, ds_confounds, [('source_file', 'source_file'),
+                                   ('confounds', 'in_file')]),
+    ])
+
+    # Resample to T1w space
+    if 'T1w' in output_spaces or 'anat' in output_spaces:
+        ds_bold_t1 = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, space='T1w', desc='preproc',
+                                keep_dtype=True, compress=True, SkullStripped=False,
+                                RepetitionTime=metadata.get('RepetitionTime')),
+            name='ds_bold_t1', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        ds_bold_t1_ref = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, space='T1w', suffix='boldref'),
+            name='ds_bold_t1_ref', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+
+        ds_bold_mask_t1 = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, space='T1w', desc='brain',
+                                suffix='mask'),
+            name='ds_bold_mask_t1', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        workflow.connect([
+            (inputnode, ds_bold_t1, [('source_file', 'source_file'),
+                                     ('bold_t1', 'in_file')]),
+            (inputnode, ds_bold_t1_ref, [('source_file', 'source_file'),
+                                         ('bold_t1_ref', 'in_file')]),
+            (inputnode, ds_bold_mask_t1, [('source_file', 'source_file'),
+                                          ('bold_mask_t1', 'in_file')]),
+            (raw_sources, ds_bold_mask_t1, [('out', 'RawSources')]),
+        ])
+        if freesurfer:
+            ds_bold_aseg_t1 = pe.Node(DerivativesDataSink(
+                base_directory=output_dir, space='T1w', desc='aseg', suffix='dseg'),
+                name='ds_bold_aseg_t1', run_without_submitting=True,
+                mem_gb=DEFAULT_MEMORY_MIN_GB)
+            ds_bold_aparc_t1 = pe.Node(DerivativesDataSink(
+                base_directory=output_dir, space='T1w', desc='aparcaseg', suffix='dseg'),
+                name='ds_bold_aparc_t1', run_without_submitting=True,
+                mem_gb=DEFAULT_MEMORY_MIN_GB)
+            workflow.connect([
+                (inputnode, ds_bold_aseg_t1, [('source_file', 'source_file'),
+                                              ('bold_aseg_t1', 'in_file')]),
+                (inputnode, ds_bold_aparc_t1, [('source_file', 'source_file'),
+                                               ('bold_aparc_t1', 'in_file')]),
+            ])
+
+    # Resample to template (default: MNI)
+    if standard_spaces:
+        ds_bold_std = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, desc='preproc',
+                                keep_dtype=True, compress=True, SkullStripped=False,
+                                RepetitionTime=metadata.get('RepetitionTime')),
+            name='ds_bold_std', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        ds_bold_std_ref = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, suffix='boldref'),
+            name='ds_bold_std_ref', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+
+        ds_bold_mask_std = pe.Node(
+            DerivativesDataSink(base_directory=output_dir, desc='brain',
+                                suffix='mask'),
+            name='ds_bold_mask_std', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        workflow.connect([
+            (inputnode, ds_bold_std, [('source_file', 'source_file'),
+                                      ('bold_std', 'in_file'),
+                                      ('template', 'space')]),
+            (inputnode, ds_bold_std_ref, [('source_file', 'source_file'),
+                                          ('bold_std_ref', 'in_file'),
+                                          ('template', 'space')]),
+            (inputnode, ds_bold_mask_std, [('source_file', 'source_file'),
+                                           ('bold_mask_std', 'in_file'),
+                                           ('template', 'space')]),
+            (raw_sources, ds_bold_mask_std, [('out', 'RawSources')]),
+        ])
+
+        if freesurfer:
+            ds_bold_aseg_std = pe.Node(DerivativesDataSink(
+                base_directory=output_dir, desc='aseg', suffix='dseg'),
+                name='ds_bold_aseg_std', run_without_submitting=True,
+                mem_gb=DEFAULT_MEMORY_MIN_GB)
+            ds_bold_aparc_std = pe.Node(DerivativesDataSink(
+                base_directory=output_dir, desc='aparcaseg', suffix='dseg'),
+                name='ds_bold_aparc_std', run_without_submitting=True,
+                mem_gb=DEFAULT_MEMORY_MIN_GB)
+            workflow.connect([
+                (inputnode, ds_bold_aseg_std, [('source_file', 'source_file'),
+                                               ('bold_aseg_std', 'in_file'),
+                                               ('template', 'space')]),
+                (inputnode, ds_bold_aparc_std, [('source_file', 'source_file'),
+                                                ('bold_aparc_std', 'in_file'),
+                                                ('template', 'space')]),
+            ])
+
+    # fsaverage space
+    if freesurfer and any(space.startswith('fs') for space in output_spaces.keys()):
+        name_surfs = pe.MapNode(GiftiNameSource(
+            pattern=r'(?P<LR>[lr])h.(?P<space>\w+).gii', template='space-{space}_hemi-{LR}.func'),
+            iterfield='in_file', name='name_surfs', mem_gb=DEFAULT_MEMORY_MIN_GB,
+            run_without_submitting=True)
+        ds_bold_surfs = pe.MapNode(DerivativesDataSink(base_directory=output_dir),
+                                   iterfield=['in_file', 'suffix'], name='ds_bold_surfs',
+                                   run_without_submitting=True,
+                                   mem_gb=DEFAULT_MEMORY_MIN_GB)
+
+        workflow.connect([
+            (inputnode, name_surfs, [('surfaces', 'in_file')]),
+            (inputnode, ds_bold_surfs, [('source_file', 'source_file'),
+                                        ('surfaces', 'in_file')]),
+            (name_surfs, ds_bold_surfs, [('out_name', 'suffix')]),
+        ])
+
+        # CIFTI output
+        if cifti_output and 'MNI152NLin2009cAsym' in output_spaces:
+            name_cifti = pe.MapNode(
+                CiftiNameSource(), iterfield=['variant'], name='name_cifti',
+                mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
+            cifti_bolds = pe.MapNode(
+                DerivativesDataSink(base_directory=output_dir, compress=False),
+                iterfield=['in_file', 'suffix'], name='cifti_bolds',
+                run_without_submitting=True, mem_gb=DEFAULT_MEMORY_MIN_GB)
+            cifti_key = pe.MapNode(DerivativesDataSink(
+                base_directory=output_dir), iterfield=['in_file', 'suffix'],
+                name='cifti_key', run_without_submitting=True,
+                mem_gb=DEFAULT_MEMORY_MIN_GB)
+            workflow.connect([
+                (inputnode, name_cifti, [('cifti_variant', 'variant')]),
+                (inputnode, cifti_bolds, [('bold_cifti', 'in_file'),
+                                          ('source_file', 'source_file')]),
+                (name_cifti, cifti_bolds, [('out_name', 'suffix')]),
+                (name_cifti, cifti_key, [('out_name', 'suffix')]),
+                (inputnode, cifti_key, [('source_file', 'source_file'),
+                                        ('cifti_variant_key', 'in_file')]),
+            ])
+
+    if use_aroma:
+        ds_aroma_noise_ics = pe.Node(DerivativesDataSink(
+            base_directory=output_dir, suffix='AROMAnoiseICs'),
+            name="ds_aroma_noise_ics", run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        ds_melodic_mix = pe.Node(DerivativesDataSink(
+            base_directory=output_dir, desc='MELODIC', suffix='mixing'),
+            name="ds_melodic_mix", run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+        ds_aroma_std = pe.Node(
+            DerivativesDataSink(base_directory=output_dir,
+                                desc='smoothAROMAnonaggr', keep_dtype=True),
+            name='ds_aroma_std', run_without_submitting=True,
+            mem_gb=DEFAULT_MEMORY_MIN_GB)
+
+        workflow.connect([
+            (inputnode, ds_aroma_noise_ics, [('source_file', 'source_file'),
+                                             ('aroma_noise_ics', 'in_file')]),
+            (inputnode, ds_melodic_mix, [('source_file', 'source_file'),
+                                         ('melodic_mix', 'in_file')]),
+            (inputnode, ds_aroma_std, [('source_file', 'source_file'),
+                                       ('nonaggr_denoised_file', 'in_file'),
+                                       ('template', 'space')]),
+        ])
+
+    return workflow
diff --git a/fmriprep/workflows/bold/registration.py b/fmriprep/workflows/bold/registration.py
index d21aa3f1e..fee264f0a 100644
--- a/fmriprep/workflows/bold/registration.py
+++ b/fmriprep/workflows/bold/registration.py
@@ -156,7 +156,7 @@ def init_bold_reg_wf(freesurfer, use_bbr, bold2t1w_dof, mem_gb, omp_nthreads,
 
     if write_report:
         ds_report_reg = pe.Node(
-            DerivativesDataSink(),
+            DerivativesDataSink(keep_dtype=True),
             name='ds_report_reg', run_without_submitting=True,
             mem_gb=DEFAULT_MEMORY_MIN_GB)
 
@@ -168,7 +168,7 @@ def _bold_reg_suffix(fallback, freesurfer):
         workflow.connect([
             (bbr_wf, ds_report_reg, [
                 ('outputnode.out_report', 'in_file'),
-                (('outputnode.fallback', _bold_reg_suffix, freesurfer), 'suffix')]),
+                (('outputnode.fallback', _bold_reg_suffix, freesurfer), 'desc')]),
         ])
 
     return workflow
@@ -275,7 +275,7 @@ def init_bold_t1_trans_wf(freesurfer, mem_gb, omp_nthreads, multiecho=False, use
         name='outputnode'
     )
 
-    gen_ref = pe.Node(GenerateSamplingReference(), name='gen_ref',
+    gen_ref = pe.Node(GenerateSamplingReference(resolution='native'), name='gen_ref',
                       mem_gb=0.3)  # 256x256x256 * 64 / 8 ~ 150MB
 
     mask_t1w_tfm = pe.Node(
diff --git a/fmriprep/workflows/bold/resampling.py b/fmriprep/workflows/bold/resampling.py
index 841d0f5da..f8d9695ad 100644
--- a/fmriprep/workflows/bold/resampling.py
+++ b/fmriprep/workflows/bold/resampling.py
@@ -6,7 +6,7 @@
 ++++++++++++++++++++
 
 .. autofunction:: init_bold_surf_wf
-.. autofunction:: init_bold_mni_trans_wf
+.. autofunction:: init_bold_std_trans_wf
 .. autofunction:: init_bold_preproc_trans_wf
 
 """
@@ -14,7 +14,6 @@
 from nipype.interfaces import utility as niu, freesurfer as fs
 from nipype.interfaces.fsl import Split as FSLSplit
 
-from templateflow.api import get as get_template
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 from niworkflows.interfaces.fixes import FixHeaderApplyTransforms as ApplyTransforms
 from niworkflows.interfaces.freesurfer import (
@@ -25,6 +24,7 @@
 )
 from niworkflows.interfaces.itk import MultiApplyTransforms
 from niworkflows.interfaces.utils import GenerateSamplingReference
+from niworkflows.interfaces.utility import KeySelect
 from niworkflows.interfaces.surf import GiftiSetAnatomicalStructure
 
 from ...interfaces import DerivativesDataSink
@@ -33,6 +33,7 @@
 from .util import init_bold_reference_wf
 
 DEFAULT_MEMORY_MIN_GB = 0.01
+NONSTANDARD_REFERENCES = ['anat', 'T1w', 'run', 'func', 'sbref', 'fsnative']
 
 
 def init_bold_surf_wf(mem_gb, output_spaces, medial_surface_nan, name='bold_surf_wf'):
@@ -167,11 +168,14 @@ def select_target(subject_id, space):
     return workflow
 
 
-def init_bold_mni_trans_wf(template, freesurfer, mem_gb, omp_nthreads,
-                           name='bold_mni_trans_wf',
-                           template_out_grid='2mm',
-                           use_compression=True,
-                           use_fieldwarp=False):
+def init_bold_std_trans_wf(
+    standard_spaces,
+    mem_gb,
+    omp_nthreads,
+    name='bold_std_trans_wf',
+    use_compression=True,
+    use_fieldwarp=False
+):
     """
     This workflow samples functional images to the MNI template in a "single shot"
     from the original BOLD series.
@@ -180,28 +184,30 @@ def init_bold_mni_trans_wf(template, freesurfer, mem_gb, omp_nthreads,
         :graph2use: colored
         :simple_form: yes
 
-        from fmriprep.workflows.bold import init_bold_mni_trans_wf
-        wf = init_bold_mni_trans_wf(template='MNI152NLin2009cAsym',
-                                    freesurfer=True,
-                                    mem_gb=3,
-                                    omp_nthreads=1,
-                                    template_out_grid='native')
+        from collections import OrderedDict
+        from fmriprep.workflows.bold import init_bold_std_trans_wf
+        wf = init_bold_std_trans_wf(
+            standard_spaces=OrderedDict([('MNI152Lin', {}),
+                                         ('fsaverage', {'density': '10k'})]),
+            mem_gb=3,
+            omp_nthreads=1,
+            template_out_grid='native')
 
     **Parameters**
 
-        template : str
-            Name of template targeted by ``template`` output space
-        freesurfer : bool
-            Enable sampling of FreeSurfer files
+        standard_spaces : OrderedDict
+            Ordered dictionary where keys are TemplateFlow ID strings (e.g. ``MNI152Lin``,
+            ``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, or ``fsLR``),
+            or paths pointing to custom templates organized in a TemplateFlow-like structure.
+            Values of the dictionary aggregate modifiers (e.g. the value for the key ``MNI152Lin``
+            could be ``{'resolution': 2}`` if one wants the resampling to be done on the 2mm
+            resolution version of the selected template).
         mem_gb : float
             Size of BOLD file in GB
         omp_nthreads : int
             Maximum number of threads an individual process may use
         name : str
-            Name of workflow (default: ``bold_mni_trans_wf``)
-        template_out_grid : str
-            Keyword ('native', '1mm' or '2mm') or path of custom reference
-            image for normalization.
+            Name of workflow (default: ``bold_std_trans_wf``)
         use_compression : bool
             Save registered BOLD series as ``.nii.gz``
         use_fieldwarp : bool
@@ -209,86 +215,109 @@ def init_bold_mni_trans_wf(template, freesurfer, mem_gb, omp_nthreads,
 
     **Inputs**
 
-        itk_bold_to_t1
-            Affine transform from ``ref_bold_brain`` to T1 space (ITK format)
-        t1_2_mni_forward_transform
-            ANTs-compatible affine-and-warp transform file
-        bold_split
-            Individual 3D volumes, not motion corrected
-        bold_mask
-            Skull-stripping mask of reference image
-        bold_aseg
-            FreeSurfer's ``aseg.mgz`` atlas projected into the T1w reference
-            (only if ``recon-all`` was run).
+        anat2std_xfm
+            List of anatomical-to-standard space transforms generated during
+            spatial normalization.
         bold_aparc
             FreeSurfer's ``aparc+aseg.mgz`` atlas projected into the T1w reference
             (only if ``recon-all`` was run).
+        bold_aseg
+            FreeSurfer's ``aseg.mgz`` atlas projected into the T1w reference
+            (only if ``recon-all`` was run).
+        bold_mask
+            Skull-stripping mask of reference image
+        bold_split
+            Individual 3D volumes, not motion corrected
+        fieldwarp
+            a :abbr:`DFM (displacements field map)` in ITK format
+        hmc_xforms
+            List of affine transforms aligning each volume to ``ref_image`` in ITK format
+        itk_bold_to_t1
+            Affine transform from ``ref_bold_brain`` to T1 space (ITK format)
         name_source
             BOLD series NIfTI file
             Used to recover original information lost during processing
-        hmc_xforms
-            List of affine transforms aligning each volume to ``ref_image`` in ITK format
-        fieldwarp
-            a :abbr:`DFM (displacements field map)` in ITK format
+        templates
+            List of templates that were applied as targets during
+            spatial normalization.
 
-    **Outputs**
+    **Outputs** - Two outputnodes are available. One output node will be parameterized
+    (with name ``poutputnode``) and a second node (``outputnode``) will collapse the
+    parameterized outputs into synchronous lists of the following fields:
 
-        bold_mni
+        bold_std
             BOLD series, resampled to template space
-        bold_mni_ref
+        bold_std_ref
             Reference, contrast-enhanced summary of the BOLD series, resampled to template space
-        bold_mask_mni
+        bold_mask_std
             BOLD series mask in template space
-        bold_aseg_mni
+        bold_aseg_std
             FreeSurfer's ``aseg.mgz`` atlas, in template space at the BOLD resolution
             (only if ``recon-all`` was run)
-        bold_aparc_mni
+        bold_aparc_std
             FreeSurfer's ``aparc+aseg.mgz`` atlas, in template space at the BOLD resolution
             (only if ``recon-all`` was run)
+        templates
+            Template identifiers synchronized correspondingly to previously
+            described outputs.
 
     """
+    from smriprep.workflows.norm import _templateflow_ds
+
+    # Filter ``standard_spaces``
+    vol_std_spaces = [k for k in standard_spaces.keys() if not k.startswith('fs')]
+    freesurfer = [k for k in standard_spaces.keys()
+                  if k.startswith('fs') and k != 'fsLR']
+
     workflow = Workflow(name=name)
-    workflow.__desc__ = """\
-The BOLD time-series were resampled to {tpl} standard space,
+
+    if len(vol_std_spaces) == 1:
+        workflow.__desc__ = """\
+The BOLD time-series were resampled into standard space,
 generating a *preprocessed BOLD run in {tpl} space*.
-""".format(tpl=template)
+""".format(tpl=vol_std_spaces)
+    else:
+        workflow.__desc__ = """\
+The BOLD time-series were resampled into several standard spaces,
+correspondingly generating the following *spatially-normalized,
+preprocessed BOLD runs*: {tpl}.
+""".format(tpl=', '.join(vol_std_spaces))
 
     inputnode = pe.Node(
         niu.IdentityInterface(fields=[
-            'itk_bold_to_t1',
-            't1_2_mni_forward_transform',
-            'name_source',
-            'bold_split',
-            'bold_mask',
-            'bold_aseg',
+            'anat2std_xfm',
             'bold_aparc',
+            'bold_aseg',
+            'bold_mask',
+            'bold_split',
+            'fieldwarp',
             'hmc_xforms',
-            'fieldwarp'
+            'itk_bold_to_t1',
+            'name_source',
+            'templates',
         ]),
         name='inputnode'
     )
 
-    outputnode = pe.Node(
-        niu.IdentityInterface(fields=[
-            'bold_mni', 'bold_mni_ref', 'bold_mask_mni',
-            'bold_aseg_mni', 'bold_aparc_mni']),
-        name='outputnode'
-    )
+    select_std = pe.Node(KeySelect(
+        fields=['resolution', 'anat2std_xfm']),
+        name='select_std', run_without_submitting=True)
+
+    select_std.inputs.resolution = [v.get('resolution') or v.get('res') or 'native'
+                                    for k, v in list(standard_spaces.items())
+                                    if k in vol_std_spaces]
+    select_std.iterables = ('key', vol_std_spaces)
 
-    def _aslist(in_value):
-        if isinstance(in_value, list):
-            return in_value
-        return [in_value]
+    select_tpl = pe.Node(niu.Function(
+        input_names=['template', 'resolution'], function=_templateflow_ds),
+        name='select_tpl', run_without_submitting=True)
 
     gen_ref = pe.Node(GenerateSamplingReference(), name='gen_ref',
                       mem_gb=0.3)  # 256x256x256 * 64 / 8 ~ 150MB)
-    gen_ref.inputs.fixed_image = str(get_template(
-        template, resolution=1, desc=None, suffix='T1w',
-        extensions=['.nii', '.nii.gz']))
 
-    mask_mni_tfm = pe.Node(
+    mask_std_tfm = pe.Node(
         ApplyTransforms(interpolation='MultiLabel', float=True),
-        name='mask_mni_tfm',
+        name='mask_std_tfm',
         mem_gb=1
     )
 
@@ -297,12 +326,18 @@ def _aslist(in_value):
                               mem_gb=DEFAULT_MEMORY_MIN_GB)
 
     workflow.connect([
+        (inputnode, select_std, [('templates', 'keys'),
+                                 ('anat2std_xfm', 'anat2std_xfm')]),
+        (inputnode, mask_std_tfm, [('bold_mask', 'input_image')]),
         (inputnode, gen_ref, [(('bold_split', _first), 'moving_image')]),
-        (inputnode, mask_mni_tfm, [('bold_mask', 'input_image')]),
-        (inputnode, mask_merge_tfms, [('t1_2_mni_forward_transform', 'in1'),
-                                      (('itk_bold_to_t1', _aslist), 'in2')]),
-        (mask_merge_tfms, mask_mni_tfm, [('out', 'transforms')]),
-        (mask_mni_tfm, outputnode, [('output_image', 'bold_mask_mni')]),
+        (inputnode, mask_merge_tfms, [(('itk_bold_to_t1', _aslist), 'in2')]),
+        (select_std, select_tpl, [('key', 'template')]),
+        (select_std, select_tpl, [('resolution', 'resolution')]),
+        (select_std, mask_merge_tfms, [('anat2std_xfm', 'in1')]),
+        (select_std, gen_ref, [('resolution', 'resolution')]),
+        (select_tpl, gen_ref, [('out', 'fixed_image')]),
+        (mask_merge_tfms, mask_std_tfm, [('out', 'transforms')]),
+        (gen_ref, mask_std_tfm, [('out_file', 'reference_image')]),
     ])
 
     nxforms = 4 if use_fieldwarp else 3
@@ -313,9 +348,9 @@ def _aslist(in_value):
     if use_fieldwarp:
         workflow.connect([(inputnode, merge_xforms, [('fieldwarp', 'in3')])])
 
-    bold_to_mni_transform = pe.Node(
+    bold_to_std_transform = pe.Node(
         MultiApplyTransforms(interpolation="LanczosWindowedSinc", float=True, copy_dtype=True),
-        name='bold_to_mni_transform', mem_gb=mem_gb * 3 * omp_nthreads, n_procs=omp_nthreads)
+        name='bold_to_std_transform', mem_gb=mem_gb * 3 * omp_nthreads, n_procs=omp_nthreads)
 
     merge = pe.Node(Merge(compress=use_compression), name='merge',
                     mem_gb=mem_gb * 3)
@@ -325,67 +360,60 @@ def _aslist(in_value):
         omp_nthreads=omp_nthreads, pre_mask=True)
 
     workflow.connect([
-        (inputnode, merge_xforms, [('t1_2_mni_forward_transform', 'in1'),
-                                   (('itk_bold_to_t1', _aslist), 'in2')]),
-        (merge_xforms, bold_to_mni_transform, [('out', 'transforms')]),
+        (inputnode, merge_xforms, [
+            ('anat2std_xfm', 'in1'),
+            (('itk_bold_to_t1', _aslist), 'in2')]),
+        (merge_xforms, bold_to_std_transform, [('out', 'transforms')]),
         (inputnode, merge, [('name_source', 'header_source')]),
-        (inputnode, bold_to_mni_transform, [('bold_split', 'input_image')]),
-        (bold_to_mni_transform, merge, [('out_files', 'in_files')]),
+        (inputnode, bold_to_std_transform, [('bold_split', 'input_image')]),
+        (bold_to_std_transform, merge, [('out_files', 'in_files')]),
         (merge, gen_final_ref, [('out_file', 'inputnode.bold_file')]),
-        (mask_mni_tfm, gen_final_ref, [('output_image', 'inputnode.bold_mask')]),
-        (merge, outputnode, [('out_file', 'bold_mni')]),
-        (gen_final_ref, outputnode, [('outputnode.ref_image', 'bold_mni_ref')]),
+        (mask_std_tfm, gen_final_ref, [('output_image', 'inputnode.bold_mask')]),
+        (gen_ref, bold_to_std_transform, [('out_file', 'reference_image')]),
     ])
 
-    if template_out_grid == 'native':
-        workflow.connect([
-            (gen_ref, mask_mni_tfm, [('out_file', 'reference_image')]),
-            (gen_ref, bold_to_mni_transform, [('out_file', 'reference_image')]),
-        ])
-    elif template_out_grid in ['1mm', '2mm']:
-        res = int(template_out_grid[0])
-        mask_mni_tfm.inputs.reference_image = str(get_template(
-            template, resolution=res, desc='brain', suffix='mask'))
-        bold_to_mni_transform.inputs.reference_image = str(get_template(
-            template, resolution=res, desc=None, suffix='T1w',
-            extensions=['.nii', '.nii.gz']))
-    else:
-        mask_mni_tfm.inputs.reference_image = template_out_grid
-        bold_to_mni_transform.inputs.reference_image = template_out_grid
+    # Connect output nodes
+    output_names = ['bold_std', 'bold_std_ref', 'bold_mask_std', 'templates']
+    if freesurfer:
+        output_names += ['bold_aseg_std', 'bold_aparc_std']
+
+    # poutputnode - parametric output node
+    poutputnode = pe.Node(niu.IdentityInterface(fields=output_names),
+                          name='poutputnode')
+
+    workflow.connect([
+        (gen_final_ref, poutputnode, [('outputnode.ref_image', 'bold_std_ref')]),
+        (merge, poutputnode, [('out_file', 'bold_std')]),
+        (mask_std_tfm, poutputnode, [('output_image', 'bold_mask_std')]),
+        (select_std, poutputnode, [('key', 'templates')]),
+    ])
 
     if freesurfer:
         # Sample the parcellation files to functional space
-        aseg_mni_tfm = pe.Node(
+        aseg_std_tfm = pe.Node(
             ApplyTransforms(interpolation='MultiLabel', float=True),
-            name='aseg_mni_tfm', mem_gb=1)
-        aparc_mni_tfm = pe.Node(
+            name='aseg_std_tfm', mem_gb=1)
+        aparc_std_tfm = pe.Node(
             ApplyTransforms(interpolation='MultiLabel', float=True),
-            name='aparc_mni_tfm', mem_gb=1)
+            name='aparc_std_tfm', mem_gb=1)
 
         workflow.connect([
-            (inputnode, aseg_mni_tfm, [('bold_aseg', 'input_image'),
-                                       ('t1_2_mni_forward_transform', 'transforms')]),
-            (inputnode, aparc_mni_tfm, [('bold_aparc', 'input_image'),
-                                        ('t1_2_mni_forward_transform', 'transforms')]),
-            (aseg_mni_tfm, outputnode, [('output_image', 'bold_aseg_mni')]),
-            (aparc_mni_tfm, outputnode, [('output_image', 'bold_aparc_mni')]),
+            (inputnode, aseg_std_tfm, [('bold_aseg', 'input_image'),
+                                       ('anat2std_xfm', 'transforms')]),
+            (inputnode, aparc_std_tfm, [('bold_aparc', 'input_image'),
+                                        ('anat2std_xfm', 'transforms')]),
+            (gen_ref, aseg_std_tfm, [('out_file', 'reference_image')]),
+            (gen_ref, aparc_std_tfm, [('out_file', 'reference_image')]),
+            (aseg_std_tfm, poutputnode, [('output_image', 'bold_aseg_std')]),
+            (aparc_std_tfm, poutputnode, [('output_image', 'bold_aparc_std')]),
         ])
-        if template_out_grid == 'native':
-            workflow.connect([
-                (gen_ref, aseg_mni_tfm, [('out_file', 'reference_image')]),
-                (gen_ref, aparc_mni_tfm, [('out_file', 'reference_image')]),
-            ])
-        elif template_out_grid in ['1mm', '2mm']:
-            entities = {'resolution': int(template_out_grid[0]),
-                        'desc': 'brain', 'suffix': 'mask',
-                        'extensions': ['.nii', '.nii.gz']}
-            aseg_mni_tfm.inputs.reference_image = str(
-                get_template(template, **entities))
-            aparc_mni_tfm.inputs.reference_image = str(
-                get_template(template, **entities))
-        else:
-            aseg_mni_tfm.inputs.reference_image = template_out_grid
-            aparc_mni_tfm.inputs.reference_image = template_out_grid
+
+    # Connect outputnode to the parameterized outputnode
+    outputnode = pe.JoinNode(niu.IdentityInterface(fields=output_names),
+                             name='outputnode', joinsource='select_std')
+    workflow.connect([
+        (poutputnode, outputnode, [(f, f) for f in output_names])
+    ])
 
     return workflow
 
@@ -414,7 +442,7 @@ def init_bold_preproc_trans_wf(mem_gb, omp_nthreads,
         omp_nthreads : int
             Maximum number of threads an individual process may use
         name : str
-            Name of workflow (default: ``bold_mni_trans_wf``)
+            Name of workflow (default: ``bold_std_trans_wf``)
         use_compression : bool
             Save registered BOLD series as ``.nii.gz``
         use_fieldwarp : bool
@@ -590,8 +618,8 @@ def init_bold_preproc_report_wf(mem_gb, reportlets_dir, name='bold_preproc_repor
     bold_rpt = pe.Node(SimpleBeforeAfter(), name='bold_rpt',
                        mem_gb=0.1)
     bold_rpt_ds = pe.Node(
-        DerivativesDataSink(base_directory=reportlets_dir,
-                            suffix='variant-preproc'), name='bold_rpt_ds',
+        DerivativesDataSink(base_directory=reportlets_dir, desc='preproc',
+                            keep_dtype=True), name='bold_rpt_ds',
         mem_gb=DEFAULT_MEMORY_MIN_GB,
         run_without_submitting=True
     )
@@ -610,3 +638,15 @@ def init_bold_preproc_report_wf(mem_gb, reportlets_dir, name='bold_preproc_repor
 
 def _first(inlist):
     return inlist[0]
+
+
+def _aslist(in_value):
+    if isinstance(in_value, list):
+        return in_value
+    return [in_value]
+
+
+def _res(in_value):
+    if in_value == 'native':
+        return 2
+    return in_value
diff --git a/fmriprep/workflows/fieldmap/__init__.py b/fmriprep/workflows/fieldmap/__init__.py
index f72270654..b7ea27a48 100644
--- a/fmriprep/workflows/fieldmap/__init__.py
+++ b/fmriprep/workflows/fieldmap/__init__.py
@@ -47,3 +47,11 @@
 from .unwarp import init_sdc_unwarp_wf, init_fmap_unwarp_report_wf
 from .pepolar import init_pepolar_unwarp_wf
 from .syn import init_syn_sdc_wf
+
+__all__ = [
+    'init_sdc_wf',
+    'init_sdc_unwarp_wf',
+    'init_fmap_unwarp_report_wf',
+    'init_pepolar_unwarp_wf',
+    'init_syn_sdc_wf',
+]
diff --git a/fmriprep/workflows/fieldmap/base.py b/fmriprep/workflows/fieldmap/base.py
index 331469cac..2c83561f3 100644
--- a/fmriprep/workflows/fieldmap/base.py
+++ b/fmriprep/workflows/fieldmap/base.py
@@ -41,6 +41,7 @@
 from nipype import logging
 
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
+from niworkflows.interfaces.utility import KeySelect
 
 # Fieldmap workflows
 from .pepolar import init_pepolar_unwarp_wf
@@ -117,11 +118,16 @@ def init_sdc_wf(fmaps, bold_meta, omp_nthreads=1,
             Brain mask for the BOLD run
         t1_brain
             T1w image, brain-masked, for the fieldmap-less SyN method
-        t1_2_mni_reverse_transform
-            MNI-to-T1w transform to map prior knowledge to the T1w
-            fo the fieldmap-less SyN method
+        std2anat_xfm
+            List of standard-to-T1w transforms generated during spatial
+            normalization (only for the fieldmap-less SyN method).
         template : str
-            Name of template targeted by ``template`` output space
+            Name of template from which prior knowledge will be mapped
+            into the subject's T1w reference
+            (only for the fieldmap-less SyN method)
+        templates : str
+            Name of templates that index the ``std2anat_xfm`` input list
+            (only for the fieldmap-less SyN method).
 
 
     **Outputs**
@@ -145,7 +151,7 @@ def init_sdc_wf(fmaps, bold_meta, omp_nthreads=1,
     workflow = Workflow(name='sdc_wf' if fmaps else 'sdc_bypass_wf')
     inputnode = pe.Node(niu.IdentityInterface(
         fields=['bold_ref', 'bold_ref_brain', 'bold_mask',
-                't1_brain', 't1_2_mni_reverse_transform', 'template']),
+                't1_brain', 'std2anat_xfm', 'template', 'templates']),
         name='inputnode')
 
     outputnode = pe.Node(niu.IdentityInterface(
@@ -236,14 +242,24 @@ def init_sdc_wf(fmaps, bold_meta, omp_nthreads=1,
 
     # FIELDMAP-less path
     if any(fm['suffix'] == 'syn' for fm in fmaps):
+        # Select template
+        sdc_select_std = pe.Node(KeySelect(
+            fields=['std2anat_xfm']),
+            name='sdc_select_std', run_without_submitting=True)
+
         syn_sdc_wf = init_syn_sdc_wf(
             bold_pe=bold_meta.get('PhaseEncodingDirection', None),
             omp_nthreads=omp_nthreads)
 
         workflow.connect([
+            (inputnode, sdc_select_std, [
+                ('template', 'key'),
+                ('templates', 'keys'),
+                ('std2anat_xfm', 'std2anat_xfm')]),
+            (sdc_select_std, syn_sdc_wf, [
+                ('std2anat_xfm', 'inputnode.std2anat_xfm')]),
             (inputnode, syn_sdc_wf, [
                 ('t1_brain', 'inputnode.t1_brain'),
-                ('t1_2_mni_reverse_transform', 'inputnode.t1_2_mni_reverse_transform'),
                 ('bold_ref', 'inputnode.bold_ref'),
                 ('bold_ref_brain', 'inputnode.bold_ref_brain'),
                 ('template', 'inputnode.template')]),
diff --git a/fmriprep/workflows/fieldmap/fmap.py b/fmriprep/workflows/fieldmap/fmap.py
index 9e1c4a2af..51c359f52 100644
--- a/fmriprep/workflows/fieldmap/fmap.py
+++ b/fmriprep/workflows/fieldmap/fmap.py
@@ -64,7 +64,7 @@ def init_fmap_wf(omp_nthreads, fmap_bspline, name='fmap_wf'):
                          name='n4_correct', n_procs=omp_nthreads)
     bet = pe.Node(BETRPT(generate_report=True, frac=0.6, mask=True),
                   name='bet')
-    ds_fmap_mask = pe.Node(DerivativesDataSink(suffix='fmap_mask'),
+    ds_fmap_mask = pe.Node(DerivativesDataSink(desc='magnitude', suffix='bold'),
                            name='ds_report_fmap_mask', run_without_submitting=True)
 
     workflow.connect([
diff --git a/fmriprep/workflows/fieldmap/phdiff.py b/fmriprep/workflows/fieldmap/phdiff.py
index 168f9b1be..f9e0f394d 100644
--- a/fmriprep/workflows/fieldmap/phdiff.py
+++ b/fmriprep/workflows/fieldmap/phdiff.py
@@ -83,7 +83,8 @@ def _pick1st(inlist):
                  name='n4', n_procs=omp_nthreads)
     bet = pe.Node(BETRPT(generate_report=True, frac=0.6, mask=True),
                   name='bet')
-    ds_fmap_mask = pe.Node(DerivativesDataSink(suffix='fmap_mask'), name='ds_report_fmap_mask',
+    ds_fmap_mask = pe.Node(DerivativesDataSink(desc='brainmask', suffix='magnitude'),
+                           name='ds_report_fmap_mask',
                            mem_gb=0.01, run_without_submitting=True)
     # uses mask from bet; outputs a mask
     # dilate = pe.Node(fsl.maths.MathsCommand(
diff --git a/fmriprep/workflows/fieldmap/syn.py b/fmriprep/workflows/fieldmap/syn.py
index 65b50bbc5..7ae22cce7 100644
--- a/fmriprep/workflows/fieldmap/syn.py
+++ b/fmriprep/workflows/fieldmap/syn.py
@@ -29,6 +29,7 @@
 from nipype.pipeline import engine as pe
 from nipype.interfaces import fsl, utility as niu
 from nipype.interfaces.image import Rescale
+
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
 from niworkflows.interfaces.fixes import (FixHeaderApplyTransforms as ApplyTransforms,
                                           FixHeaderRegistration as Registration)
@@ -74,7 +75,7 @@ def init_syn_sdc_wf(omp_nthreads, bold_pe=None,
             Name of template targeted by ``template`` output space
         t1_brain
             skull-stripped, bias-corrected structural image
-        t1_2_mni_reverse_transform
+        std2anat_xfm
             inverse registration transform of T1w image to MNI template
 
     **Outputs**
@@ -109,7 +110,7 @@ def init_syn_sdc_wf(omp_nthreads, bold_pe=None,
 """.format(ants_ver=Registration().version or '<ver>')
     inputnode = pe.Node(
         niu.IdentityInterface(['bold_ref', 'bold_ref_brain', 'template',
-                               't1_brain', 't1_2_mni_reverse_transform']),
+                               't1_brain', 'std2anat_xfm']),
         name='inputnode')
     outputnode = pe.Node(
         niu.IdentityInterface(['out_reference', 'out_reference_brain',
@@ -174,7 +175,7 @@ def init_syn_sdc_wf(omp_nthreads, bold_pe=None,
         (ref_2_t1, t1_2_ref, [('forward_transforms', 'transforms')]),
         (ref_2_t1, transform_list, [('forward_transforms', 'in1')]),
         (inputnode, transform_list, [
-            ('t1_2_mni_reverse_transform', 'in2'),
+            ('std2anat_xfm', 'in2'),
             (('template', _prior_path), 'in3')]),
         (inputnode, atlas_2_ref, [('bold_ref', 'reference_image')]),
         (transform_list, atlas_2_ref, [('out', 'transforms')]),
@@ -199,6 +200,7 @@ def init_syn_sdc_wf(omp_nthreads, bold_pe=None,
 
 
 def _prior_path(template):
+    """Selects an appropriate input xform, based on template"""
     from pkg_resources import resource_filename
     return resource_filename(
         'fmriprep', 'data/fmap_atlas_2_{}_affine.mat'.format(template))
diff --git a/fmriprep/workflows/fieldmap/unwarp.py b/fmriprep/workflows/fieldmap/unwarp.py
index aa8ec9ae3..4508f6b15 100644
--- a/fmriprep/workflows/fieldmap/unwarp.py
+++ b/fmriprep/workflows/fieldmap/unwarp.py
@@ -105,7 +105,8 @@ def init_sdc_unwarp_wf(omp_nthreads, fmap_demean, debug, name='sdc_unwarp_wf'):
                             output_inverse_warped_image=True, output_warped_image=True),
         name='fmap2ref_reg', n_procs=omp_nthreads)
 
-    ds_reg = pe.Node(DerivativesDataSink(suffix='fmap_reg'), name='ds_report_reg',
+    ds_reg = pe.Node(DerivativesDataSink(keep_dtype=True, desc='magnitude'),
+                     name='ds_report_reg',
                      mem_gb=0.01, run_without_submitting=True)
 
     # Map the VSM into the EPI space
@@ -118,7 +119,8 @@ def init_sdc_unwarp_wf(omp_nthreads, fmap_demean, debug, name='sdc_unwarp_wf'):
         float=True),
         name='fmap_mask2ref_apply')
 
-    ds_reg_vsm = pe.Node(DerivativesDataSink(suffix='fmap_reg_vsm'), name='ds_report_vsm',
+    ds_reg_vsm = pe.Node(DerivativesDataSink(keep_dtype=True, desc='fieldmap'),
+                         name='ds_report_vsm',
                          mem_gb=0.01, run_without_submitting=True)
 
     # Fieldmap to rads and then to voxels (VSM - voxel shift map)
@@ -211,7 +213,7 @@ def init_sdc_unwarp_wf(omp_nthreads, fmap_demean, debug, name='sdc_unwarp_wf'):
     return workflow
 
 
-def init_fmap_unwarp_report_wf(name='fmap_unwarp_report_wf', suffix='variant-hmcsdc_preproc'):
+def init_fmap_unwarp_report_wf(name='fmap_unwarp_report_wf', suffix='sdc'):
     """
     This workflow generates and saves a reportlet showing the effect of fieldmap
     unwarping a BOLD image.
@@ -228,7 +230,7 @@ def init_fmap_unwarp_report_wf(name='fmap_unwarp_report_wf', suffix='variant-hmc
         name : str, optional
             Workflow name (default: fmap_unwarp_report_wf)
         suffix : str, optional
-            Suffix to be appended to this reportlet
+            Desc field to be inserted in the final name of this reportlet.
 
     **Inputs**
 
@@ -264,7 +266,7 @@ def init_fmap_unwarp_report_wf(name='fmap_unwarp_report_wf', suffix='variant-hmc
     bold_rpt = pe.Node(SimpleBeforeAfter(), name='bold_rpt',
                        mem_gb=0.1)
     ds_report_sdc = pe.Node(
-        DerivativesDataSink(suffix=suffix), name='ds_report_sdc',
+        DerivativesDataSink(desc=suffix, keep_dtype=True), name='ds_report_sdc',
         mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True
     )
 
diff --git a/requirements.txt b/requirements.txt
index 570089928..8dd1c7e6b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
-git+https://github.com/poldracklab/niworkflows.git@b7d111c8fd36a099c74be5e7671677eedb175533#egg=niworkflows
-git+https://github.com/poldracklab/smriprep.git@423bcc43ab7300177eb3b98da62817b2cad8eb87#egg=smriprep-0.1.0
+git+https://github.com/poldracklab/niworkflows.git@unstable#egg=niworkflows
+git+https://github.com/poldracklab/smriprep.git@unstable#egg=smriprep-0.1.0
 templateflow<0.2.0a0,>=0.1.3
diff --git a/setup.py b/setup.py
index 5d253d1e4..5d347b322 100644
--- a/setup.py
+++ b/setup.py
@@ -39,8 +39,6 @@ def main():
             'data/boilerplate.bib',
             'data/itkIdentityTransform.txt',
             'data/flirtsch/bbr.sch',
-            'viz/*.tpl',
-            'viz/*.json',
         ]
     }
 

From 34767666a12ed97446ff7828c53700010001c122 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Mon, 29 Apr 2019 22:49:03 -0700
Subject: [PATCH 02/24] fix(cli,tests): fix typos on MNI152NLin6Asym name,
 improve Circle config

---
 .circleci/config.yml |  1 +
 fmriprep/cli/run.py  | 10 +++++-----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 7597b7ecd..67022c7e3 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -392,6 +392,7 @@ jobs:
                 -e FMRIPREP_DEV 1 -u $(id -u) \
                 --config $PWD/nipype.cfg -w /tmp/ds005/work \
                 /tmp/data/ds005 /tmp/ds005/derivatives participant \
+                --output-spaces MNI152NLin2009cAsym MNI152NLin6Asym \
                 --sloppy --write-graph --mem_mb 4096 \
                 --nthreads 2 --anat-only -vv
       - save_cache:
diff --git a/fmriprep/cli/run.py b/fmriprep/cli/run.py
index ac13ebfd8..c3ec210e6 100755
--- a/fmriprep/cli/run.py
+++ b/fmriprep/cli/run.py
@@ -640,7 +640,7 @@ def parse_spaces(opts):
     from sys import stderr
     from collections import OrderedDict
     from templateflow.api import templates as get_templates
-    # Set the default template to 'MNI152NLin2009c'
+    # Set the default template to 'MNI152NLin2009cAsym'
     output_spaces = opts.output_spaces or OrderedDict([('MNI152NLin2009cAsym', {})])
 
     if opts.template:
@@ -678,17 +678,17 @@ def parse_spaces(opts):
     # Validity of some inputs
     # ERROR check if use_aroma was specified, but the correct template was not
     if opts.use_aroma and 'MNI152NLin6Asym' not in output_spaces:
-        output_spaces['MNI152Lin6Asym'] = {'res': 2}
+        output_spaces['MNI152NLin6Asym'] = {'res': 2}
         print("""\
-Option "--use-aroma" requires functional images to be resampled to MNI152Lin6Asym space. \
-The argument "MNI152Lin6Asym:res-2" has been automatically added to the list of output spaces \
+Option "--use-aroma" requires functional images to be resampled to MNI152NLin6Asym space. \
+The argument "MNI152NLin6Asym:res-2" has been automatically added to the list of output spaces \
 (option ``--output-spaces``).""", file=stderr)
 
     if opts.cifti_output and 'fsLR' not in output_spaces:
         if 'MNI152NLin6Asym' not in output_spaces:
             output_spaces['MNI152NLin6Asym'] = {'res': 2}
             print("""Option ``--cifti-output`` requires functional images to be resampled to \
-``MNI152LinAsym`` space. Such template identifier has been automatically added to the list \
+``MNI152NLin6Asym`` space. Such template identifier has been automatically added to the list \
 of output spaces (option "--output-space").""", file=stderr)
         if not [s for s in output_spaces if s in ('fsaverage5', 'fsaverage6')]:
             output_spaces['fsaverage5'] = {}

From aa1456e7fe8f3ff6fe469f54dc2d33cd931a2b35 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Mon, 29 Apr 2019 22:55:54 -0700
Subject: [PATCH 03/24] fix(sentry): fix bug in ``_chunks`` and corresponding
 doctest

---
 fmriprep/utils/sentry.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/fmriprep/utils/sentry.py b/fmriprep/utils/sentry.py
index 290c9702a..0ae34daf9 100644
--- a/fmriprep/utils/sentry.py
+++ b/fmriprep/utils/sentry.py
@@ -53,13 +53,13 @@ def sentry_setup(opts, exec_env):
     import psutil
     import hashlib
     from ..__about__ import __version__
-    from ..utils.sentry import before_send
+
     environment = "prod"
     release = __version__
     if not __version__:
         environment = "dev"
         release = "dev"
-    elif int(os.getenv('FMRIPREP_DEV', 0)) or ('+' in __version__):
+    elif int(os.getenv('FMRIPREP_DEV', '0')) or ('+' in __version__):
         environment = "dev"
 
     sentry_sdk.init("https://d5a16b0c38d84d1584dfc93b9fb1ade6@sentry.io/1137693",
@@ -180,9 +180,9 @@ def before_send(event, hints):
         msg = event['logentry']['message']
         if msg.startswith("could not run node:"):
             return None
-        elif msg.startswith("Saving crash info to "):
+        if msg.startswith("Saving crash info to "):
             return None
-        elif re.match("Node .+ failed to run on host .+", msg):
+        if re.match("Node .+ failed to run on host .+", msg):
             return None
 
     if 'breadcrumbs' in event and isinstance(event['breadcrumbs'], list):
@@ -201,9 +201,9 @@ def _chunks(string, length=CHUNK_SIZE):
     """
     Splits a string into smaller chunks
 
-    >>> list(_chunks('some longer string', length=3))
+    >>> list(_chunks('some longer string.', length=3))
     ['som', 'e l', 'ong', 'er ', 'str', 'ing', '.']
 
     """
-    return (string[i:i + CHUNK_SIZE]
+    return (string[i:i + length]
             for i in range(0, len(string), length))

From 416610f870b8c8d85242fac3241cb062d305be30 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Mon, 29 Apr 2019 23:09:25 -0700
Subject: [PATCH 04/24] fix(workflow): resolve inconsistency with
 ``--fs-no-reconall``

---
 fmriprep/workflows/bold/base.py | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/fmriprep/workflows/bold/base.py b/fmriprep/workflows/bold/base.py
index 65a03bb0c..03d06990e 100755
--- a/fmriprep/workflows/bold/base.py
+++ b/fmriprep/workflows/bold/base.py
@@ -728,11 +728,20 @@ def init_func_preproc_wf(
                 ('outputnode.out_warp', 'inputnode.fieldwarp')]),
             (bold_std_trans_wf, outputnode, [('outputnode.bold_std', 'bold_std'),
                                              ('outputnode.bold_std_ref', 'bold_std_ref'),
-                                             ('outputnode.bold_mask_std', 'bold_mask_std'),
-                                             ('outputnode.bold_aseg_std', 'bold_aseg_std'),
-                                             ('outputnode.bold_aparc_std', 'bold_aparc_std')]),
+                                             ('outputnode.bold_mask_std', 'bold_mask_std')]),
         ])
 
+        if freesurfer:
+            workflow.connect([
+                (bold_std_trans_wf, func_derivatives_wf, [
+                    ('poutputnode.bold_aseg_std', 'inputnode.bold_aseg_std'),
+                    ('poutputnode.bold_aparc_std', 'inputnode.bold_aparc_std'),
+                ]),
+                (bold_std_trans_wf, outputnode, [
+                    ('outputnode.bold_aseg_std', 'bold_aseg_std'),
+                    ('outputnode.bold_aparc_std', 'bold_aparc_std')]),
+            ])
+
         if 'MNI152NLin2009cAsym' in std_spaces:
             carpetplot_wf = init_carpetplot_wf(
                 standard_spaces=std_spaces,
@@ -773,8 +782,6 @@ def init_func_preproc_wf(
             (bold_std_trans_wf, func_derivatives_wf, [
                 ('poutputnode.bold_std_ref', 'inputnode.bold_std_ref'),
                 ('poutputnode.bold_std', 'inputnode.bold_std'),
-                ('poutputnode.bold_aseg_std', 'inputnode.bold_aseg_std'),
-                ('poutputnode.bold_aparc_std', 'inputnode.bold_aparc_std'),
                 ('poutputnode.bold_mask_std', 'inputnode.bold_mask_std'),
             ]),
         ])

From 2c5cc9f8267ac609f7740a587e1cc3faff963087 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 07:38:28 -0700
Subject: [PATCH 05/24] fix(Dockerfile): make TEMPLATEFLOW_HOME writable

---
 Dockerfile | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 6f2cc3797..1f97edcea 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -164,10 +164,11 @@ ENV TEMPLATEFLOW_HOME="/opt/templateflow"
 RUN mkdir -p $TEMPLATEFLOW_HOME
 RUN pip install --no-cache-dir "templateflow>=0.1.3,<0.2.0a0" && \
     python -c "from templateflow import api as tfapi; \
-               tfapi.get('MNI152Lin'); \
+               tfapi.get('MNI152NLin6Asym'); \
                tfapi.get('MNI152NLin2009cAsym'); \
-               tfapi.get('OASIS30ANTs'); \
-               tfapi.get('NKI');"
+               tfapi.get('OASIS30ANTs');" && \
+    find $TEMPLATEFLOW_HOME -type d -exec chmod go=u {} + && \
+    find $TEMPLATEFLOW_HOME -type f -exec chmod go=u {} +
 
 # Installing dev requirements (packages that are not in pypi)
 WORKDIR /src/

From a58acd309f5ed9875f04f646d839e53be6c7b1d6 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 07:41:25 -0700
Subject: [PATCH 06/24] fix(wrapper): resolve falsely clobbering error

---
 wrapper/fmriprep_docker.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/wrapper/fmriprep_docker.py b/wrapper/fmriprep_docker.py
index 0be5cdccf..23a5c2c02 100755
--- a/wrapper/fmriprep_docker.py
+++ b/wrapper/fmriprep_docker.py
@@ -173,7 +173,8 @@ def merge_help(wrapper_help, target_help):
     # Make sure we're not clobbering options we don't mean to
     overlap = set(w_flags).intersection(t_flags)
     expected_overlap = set(['h', 'version', 'w', 'template-resampling-grid',
-                            'output-grid-reference', 'fs-license-file', 'use-plugin'])
+                            'fs-license-file', 'use-plugin'])
+    print(overlap, expected_overlap)
     assert overlap == expected_overlap, "Clobbering options: {}".format(
         ', '.join(overlap - expected_overlap))
 

From c47719186534644c653a34306b40b2986c5233f6 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 09:43:09 -0700
Subject: [PATCH 07/24] fix(workflow): update to use new boolean trait, fix
 querying templates

for resolution == 'native'.
---
 fmriprep/workflows/bold/confounds.py    |  2 --
 fmriprep/workflows/bold/registration.py |  2 +-
 fmriprep/workflows/bold/resampling.py   | 11 +++++++----
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/fmriprep/workflows/bold/confounds.py b/fmriprep/workflows/bold/confounds.py
index 3ec068e27..c86ff1e4c 100755
--- a/fmriprep/workflows/bold/confounds.py
+++ b/fmriprep/workflows/bold/confounds.py
@@ -33,8 +33,6 @@
     FMRISummary, DerivativesDataSink
 )
 
-from .resampling import init_bold_std_trans_wf
-
 DEFAULT_MEMORY_MIN_GB = 0.01
 
 
diff --git a/fmriprep/workflows/bold/registration.py b/fmriprep/workflows/bold/registration.py
index fee264f0a..827cbbe37 100644
--- a/fmriprep/workflows/bold/registration.py
+++ b/fmriprep/workflows/bold/registration.py
@@ -275,7 +275,7 @@ def init_bold_t1_trans_wf(freesurfer, mem_gb, omp_nthreads, multiecho=False, use
         name='outputnode'
     )
 
-    gen_ref = pe.Node(GenerateSamplingReference(resolution='native'), name='gen_ref',
+    gen_ref = pe.Node(GenerateSamplingReference(keep_native=True), name='gen_ref',
                       mem_gb=0.3)  # 256x256x256 * 64 / 8 ~ 150MB
 
     mask_t1w_tfm = pe.Node(
diff --git a/fmriprep/workflows/bold/resampling.py b/fmriprep/workflows/bold/resampling.py
index f8d9695ad..ca820ab52 100644
--- a/fmriprep/workflows/bold/resampling.py
+++ b/fmriprep/workflows/bold/resampling.py
@@ -332,9 +332,9 @@ def init_bold_std_trans_wf(
         (inputnode, gen_ref, [(('bold_split', _first), 'moving_image')]),
         (inputnode, mask_merge_tfms, [(('itk_bold_to_t1', _aslist), 'in2')]),
         (select_std, select_tpl, [('key', 'template')]),
-        (select_std, select_tpl, [('resolution', 'resolution')]),
+        (select_std, select_tpl, [(('resolution', _tpl_res), 'resolution')]),
         (select_std, mask_merge_tfms, [('anat2std_xfm', 'in1')]),
-        (select_std, gen_ref, [('resolution', 'resolution')]),
+        (select_std, gen_ref, [(('resolution', _is_native), 'keep_native')]),
         (select_tpl, gen_ref, [('out', 'fixed_image')]),
         (mask_merge_tfms, mask_std_tfm, [('out', 'transforms')]),
         (gen_ref, mask_std_tfm, [('out_file', 'reference_image')]),
@@ -646,7 +646,10 @@ def _aslist(in_value):
     return [in_value]
 
 
-def _res(in_value):
+def _is_native(in_value):
+    return in_value == 'native'
+
+
+def _tpl_res(in_value):
     if in_value == 'native':
         return 2
-    return in_value

From fd5a3f356112160a9bc5000b9cdd77996b778b52 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 10:57:52 -0700
Subject: [PATCH 08/24] fix(docs): now documentation builds (depends on changes
 on sMRIPrep)

---
 docs/usage.rst                        |  9 +--
 docs/workflows.rst                    | 85 +++++++++++++--------------
 fmriprep/workflows/bold/confounds.py  |  3 +-
 fmriprep/workflows/bold/resampling.py |  2 +-
 4 files changed, 49 insertions(+), 50 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index 8dd0f9563..df67ac25a 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -37,6 +37,7 @@ Command-Line Arguments
    :nodefault:
    :nodefaultconst:
 
+
 Defining standard and nonstandard spaces where data will be resampled
 =====================================================================
 
@@ -46,7 +47,7 @@ That is achieved using the ``--output-spaces`` argument, where standard and
 nonstandard spaces can be inserted.
 
 Standard spaces
----------------
+"""""""""""""""
 
 When using fMRIPrep in a workflow that will investigate effects that span across
 analytical groupings, neuroimagers typically resample their data on to a standard,
@@ -88,7 +89,7 @@ FreeSurfer will be supported (e.g. ``fsaverage5``) although the use of the densi
 modifier would be preferred (i.e. ``fsaverage:den-10k`` for ``fsaverage5``).
 
 Custom standard spaces
-----------------------
+""""""""""""""""""""""
 
 Although the functionality is not available yet, the interface of the
 ``--output-spaces`` permits providing paths to custom templates that
@@ -107,7 +108,7 @@ must be found under under ``/path/to/custom/templates/tpl-MyCustom``: ::
 Although a more comprehensive coverage of standard files would be advised.
 
 Nonstandard spaces
-------------------
+""""""""""""""""""
 
 Additionally, ``--output-spaces`` accepts identifiers of spatial references
 that do not generate *standardized* coordinate spaces:
@@ -125,7 +126,7 @@ that do not generate *standardized* coordinate spaces:
 Modifiers are not allowed when providing nonstandard spaces.
 
 Preprocessing blocks depending on standard templates
-----------------------------------------------------
+""""""""""""""""""""""""""""""""""""""""""""""""""""
 
 Some modules of the pipeline (e.g. the ICA-AROMA denoising, the generation of
 HCP compatible *grayordinates* files, or the *fieldmap-less* distortion correction)
diff --git a/docs/workflows.rst b/docs/workflows.rst
index ff015539c..66e7cd1e2 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -19,44 +19,43 @@ is presented below:
     :simple_form: yes
 
     from fmriprep.workflows.base import init_single_subject_wf
-    from collections import namedtuple
+    from collections import namedtuple, OrderedDict
     BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
     wf = init_single_subject_wf(
-        layout=BIDSLayout(),
-        subject_id='test',
-        name='single_subject_wf',
-        task_id='',
+        anat_only=False,
+        aroma_melodic_dim=-200,
+        bold2t1w_dof=9,
+        cifti_output=False,
+        debug=False,
         echo_idx=None,
+        err_on_aroma_warn=False,
+        fmap_bspline=False,
+        fmap_demean=True,
+        force_syn=True,
+        freesurfer=True,
+        hires=True,
+        ignore=[],
+        layout=BIDSLayout(),
         longitudinal=False,
-        t2s_coreg=False,
+        low_mem=False,
+        medial_surface_nan=False,
+        name='single_subject_wf',
         omp_nthreads=1,
-        freesurfer=True,
-        reportlets_dir='.',
         output_dir='.',
-        skull_strip_template='OASIS30ANTs',
+        output_spaces=OrderedDict([
+            ('MNI152Lin', {}), ('fsaverage', {'density': '10k'}),
+            ('T1w', {}), ('fsnative', {})]),
+        reportlets_dir='.',
         skull_strip_fixed_seed=False,
-        template='MNI152NLin2009cAsym',
-        output_spaces=['T1w', 'fsnative', 'template', 'fsaverage5'],
-        medial_surface_nan=False,
-        cifti_output=False,
-        ignore=[],
-        debug=False,
-        low_mem=False,
-        anat_only=False,
-        hires=True,
+        skull_strip_template='OASIS30ANTs',
+        subject_id='test',
+        t2s_coreg=False,
+        task_id='',
+        use_aroma=False,
         use_bbr=True,
-        bold2t1w_dof=9,
-        fmap_bspline=False,
-        fmap_demean=True,
         use_syn=True,
-        force_syn=True,
-        template_out_grid='native',
-        use_aroma=False,
-        aroma_melodic_dim=-200,
-        err_on_aroma_warn=False,
     )
 
-
 T1w/T2w preprocessing
 ---------------------
 :mod:`fmriprep.workflows.anatomical.init_anat_preproc_wf`
@@ -65,22 +64,20 @@ T1w/T2w preprocessing
     :graph2use: orig
     :simple_form: yes
 
+    from collections import OrderedDict
     from fmriprep.workflows.anatomical import init_anat_preproc_wf
     wf = init_anat_preproc_wf(
         bids_root='.',
-        debug=False,
         freesurfer=True,
-        fs_spaces=['T1w', 'fsnative',
-                   'template', 'fsaverage5'],
         hires=True,
         longitudinal=False,
         num_t1w=1,
         omp_nthreads=1,
         output_dir='.',
+        output_spaces=OrderedDict([
+            ('MNI152NLin2009cAsym', {}), ('fsaverage5', {})]),
         reportlets_dir='.',
         skull_strip_template='MNI152NLin2009cAsym',
-        skull_strip_fixed_seed=False,
-        template='MNI152NLin2009cAsym',
     )
 
 The anatomical sub-workflow begins by constructing an average image by
@@ -274,13 +271,13 @@ BOLD preprocessing
     :graph2use: orig
     :simple_form: yes
 
-    from collections import namedtuple
+    from collections import namedtuple, OrderedDict
+    from fmriprep.workflows.bold.base import init_func_preproc_wf
     BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
-    from fmriprep.workflows.bold import init_func_preproc_wf
     wf = init_func_preproc_wf(
-        '/completely/made/up/path/sub-01_task-nback_bold.nii.gz',
         aroma_melodic_dim=-200,
         bold2t1w_dof=9,
+        bold_file='/completely/made/up/path/sub-01_task-nback_bold.nii.gz',
         cifti_output=False,
         debug=False,
         err_on_aroma_warn=False,
@@ -289,19 +286,20 @@ BOLD preprocessing
         force_syn=True,
         freesurfer=True,
         ignore=[],
-        layout=BIDSLayout(),
         low_mem=False,
         medial_surface_nan=False,
         omp_nthreads=1,
         output_dir='.',
-        output_spaces=['T1w', 'fsnative', 'template', 'fsaverage5'],
+        output_spaces=OrderedDict([
+            ('MNI152Lin', {}), ('fsaverage', {'density': '10k'}),
+            ('T1w', {}), ('fsnative', {})]),
         reportlets_dir='.',
         t2s_coreg=False,
-        template='MNI152NLin2009cAsym',
-        template_out_grid='native',
         use_aroma=False,
         use_bbr=True,
         use_syn=True,
+        layout=BIDSLayout(),
+        num_bold=1,
     )
 
 Preprocessing of :abbr:`BOLD (blood-oxygen level-dependent)` files is
@@ -478,13 +476,14 @@ EPI to MNI transformation
     :graph2use: colored
     :simple_form: yes
 
+    from collections import OrderedDict
     from fmriprep.workflows.bold import init_bold_std_trans_wf
     wf = init_bold_std_trans_wf(
-        template='MNI152NLin2009cAsym',
-		freesurfer=True,
-        mem_gb=1,
+        standard_spaces=OrderedDict([('MNI152Lin', {}),
+                                     ('fsaverage', {'density': '10k'})]),
+        mem_gb=3,
         omp_nthreads=1,
-        template_out_grid='native')
+    )
 
 This sub-workflow concatenates the transforms calculated upstream (see
 `Head-motion estimation`_, `Susceptibility Distortion Correction (SDC)`_ --if
diff --git a/fmriprep/workflows/bold/confounds.py b/fmriprep/workflows/bold/confounds.py
index c86ff1e4c..e0a740574 100755
--- a/fmriprep/workflows/bold/confounds.py
+++ b/fmriprep/workflows/bold/confounds.py
@@ -439,8 +439,7 @@ def init_ica_aroma_wf(metadata, mem_gb, omp_nthreads,
         :simple_form: yes
 
         from fmriprep.workflows.bold.confounds import init_ica_aroma_wf
-        wf = init_ica_aroma_wf(template='MNI152NLin2009cAsym',
-                               metadata={'RepetitionTime': 1.0},
+        wf = init_ica_aroma_wf(metadata={'RepetitionTime': 1.0},
                                mem_gb=3,
                                omp_nthreads=1)
 
diff --git a/fmriprep/workflows/bold/resampling.py b/fmriprep/workflows/bold/resampling.py
index ca820ab52..6c586d9c9 100644
--- a/fmriprep/workflows/bold/resampling.py
+++ b/fmriprep/workflows/bold/resampling.py
@@ -191,7 +191,7 @@ def init_bold_std_trans_wf(
                                          ('fsaverage', {'density': '10k'})]),
             mem_gb=3,
             omp_nthreads=1,
-            template_out_grid='native')
+        )
 
     **Parameters**
 

From cd6e93002a3e72459924fc3e8234dddc02b9f37f Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 13:01:10 -0700
Subject: [PATCH 09/24] fix(workflow): this function was setting ``resolution``
 to ``None``

---
 fmriprep/workflows/bold/resampling.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fmriprep/workflows/bold/resampling.py b/fmriprep/workflows/bold/resampling.py
index 6c586d9c9..5e89391b2 100644
--- a/fmriprep/workflows/bold/resampling.py
+++ b/fmriprep/workflows/bold/resampling.py
@@ -653,3 +653,4 @@ def _is_native(in_value):
 def _tpl_res(in_value):
     if in_value == 'native':
         return 2
+    return in_value

From 926e4bf4923878ca2338a934fbed37fecfff7885 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 13:01:50 -0700
Subject: [PATCH 10/24] pin(smriprep): hook to current master

---
 fmriprep/__about__.py | 4 ++--
 requirements.txt      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index f0a5d46c7..a996b85da 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -106,8 +106,8 @@
 LINKS_REQUIRES = [
     'git+https://github.com/poldracklab/niworkflows.git@'
     'unstable#egg=niworkflows',
-    'git+https://github.com/poldracklab/unstable.git@'
-    '423bcc43ab7300177eb3b98da62817b2cad8eb87#egg=smriprep-0.1.0',
+    'git+https://github.com/poldracklab/smriprep.git@'
+    'master#egg=smriprep-0.1.0',
 ]
 
 TESTS_REQUIRES = [
diff --git a/requirements.txt b/requirements.txt
index 8dd1c7e6b..4a7b11cf3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
 git+https://github.com/poldracklab/niworkflows.git@unstable#egg=niworkflows
-git+https://github.com/poldracklab/smriprep.git@unstable#egg=smriprep-0.1.0
+git+https://github.com/poldracklab/smriprep.git@master#egg=smriprep-0.1.0
 templateflow<0.2.0a0,>=0.1.3

From e90299a0d01e76a6bc471bd9083f434ad590a77d Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 14:38:56 -0700
Subject: [PATCH 11/24] doc: MNI -> standard space, stylistic changes.

---
 docs/usage.rst                        |  2 +
 docs/workflows.rst                    | 64 +++++++++++++--------------
 fmriprep/workflows/bold/resampling.py |  4 +-
 3 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index df67ac25a..5ad182a08 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -38,6 +38,8 @@ Command-Line Arguments
    :nodefaultconst:
 
 
+.. _output_spaces:
+
 Defining standard and nonstandard spaces where data will be resampled
 =====================================================================
 
diff --git a/docs/workflows.rst b/docs/workflows.rst
index 66e7cd1e2..e9b4ab81d 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -4,7 +4,7 @@
 Processing pipeline details
 ===========================
 
-``fmriprep`` adapts its pipeline depending on what data and metadata are
+*fMRIPrep* adapts its pipeline depending on what data and metadata are
 available and are used as the input.
 For example, slice timing correction will be
 performed only if the ``SliceTiming`` metadata field is found for the input
@@ -118,22 +118,23 @@ Once the brain mask is computed, FSL ``fast`` is utilized for brain tissue segme
     Brain tissue segmentation.
 
 
-Finally, spatial normalization to MNI-space is performed using ANTs' ``antsRegistration``
+Finally, spatial normalization to standard spaces is performed using ANTs' ``antsRegistration``
 in a multiscale, mutual-information based, nonlinear registration scheme.
-In particular, spatial normalization is done using the `ICBM 2009c Nonlinear
-Asymmetric template (1×1×1mm) <http://nist.mni.mcgill.ca/?p=904>`_ [Fonov2011]_.
+See `output_spaces`_ for information about how standard and nonstandard spaces can
+be set to resample the preprocessed data onto the final output spaces.
+
 
 .. figure:: _static/T1MNINormalization.svg
     :scale: 100%
 
-    Animation showing T1w to MNI normalization
+    Animation showing spatial normalization of T1w onto the ``MNI152NLin2009cAsym`` template.
 
 Cost function masking during spatial normalization
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When processing images from patients with focal brain lesions (e.g. stroke, tumor
 resection), it is possible to provide a lesion mask to be used during spatial
-normalization to MNI-space [Brett2001]_.
+normalization to standard space [Brett2001]_.
 ANTs will use this mask to minimize warping of healthy tissue into damaged
 areas (or vice-versa).
 Lesion masks should be binary NIfTI images (damaged areas = 1, everywhere else = 0)
@@ -141,11 +142,11 @@ in the same space and resolution as the T1 image, and follow the naming conventi
 `BIDS Extension Proposal 3: Common Derivatives <https://docs.google.com/document/d/1Wwc4A6Mow4ZPPszDIWfCUCRNstn7d_zzaWPcfcHmgI4/edit#heading=h.9146wuepclkt>`_
 (e.g. ``sub-001_T1w_label-lesion_roi.nii.gz``).
 This file should be placed in the ``sub-*/anat`` directory of the BIDS dataset
-to be run through ``fmriprep``.
+to be run through *fMRIPrep*.
 Because lesion masks are not currently part of the BIDS specification, it is also necessary to 
 include a ``.bidsignore`` file in the root of your dataset directory. This will prevent 
 `bids-validator <https://github.com/bids-standard/bids-validator#bidsignore>`_ from complaining that your dataset not BIDS valid, which prevents 
-``fmriprep`` from running. Your ``.bidsignore`` file should include the following line::
+*fMRIPrep* from running. Your ``.bidsignore`` file should include the following line::
 
 *lesion_roi.nii.gz
 
@@ -159,7 +160,7 @@ aligned to the first image (determined lexicographically by session label).
 For two images, the additional cost of estimating an unbiased template is
 trivial and is the default behavior, but, for greater than two images, the cost
 can be a slowdown of an order of magnitude.
-Therefore, in the case of three or more images, ``fmriprep`` constructs
+Therefore, in the case of three or more images, *fMRIPrep* constructs
 templates aligned to the first image, unless passed the ``--longitudinal``
 flag, which forces the estimation of an unbiased template.
 
@@ -186,17 +187,17 @@ Surface preprocessing
     wf = init_surface_recon_wf(omp_nthreads=1,
                                hires=True)
 
-``fmriprep`` uses FreeSurfer_ to reconstruct surfaces from T1w/T2w
+*fMRIPrep* uses FreeSurfer_ to reconstruct surfaces from T1w/T2w
 structural images.
-If enabled, several steps in the ``fmriprep`` pipeline are added or replaced.
+If enabled, several steps in the *fMRIPrep* pipeline are added or replaced.
 All surface preprocessing may be disabled with the ``--fs-no-reconall`` flag.
 
 .. note::
     Surface processing will be skipped if the outputs already exist.
 
-    In order to bypass reconstruction in ``fmriprep``, place existing reconstructed
+    In order to bypass reconstruction in *fMRIPrep*, place existing reconstructed
     subjects in ``<output dir>/freesurfer`` prior to the run.
-    ``fmriprep`` will perform any missing ``recon-all`` steps, but will not perform
+    *fMRIPrep* will perform any missing ``recon-all`` steps, but will not perform
     any steps whose outputs already exist.
 
 
@@ -258,7 +259,7 @@ will contain some innaccuracies including small amounts of MR signal from
 outside the brain.
 Based on the tissue segmentation of FreeSurfer (located in ``mri/aseg.mgz``)
 and only when the :ref:`Surface Processing <workflows_surface>` step has been
-executed, FMRIPREP replaces the brain mask with a refined one that derives
+executed, *fMRIPrep* replaces the brain mask with a refined one that derives
 from the ``aseg.mgz`` file as described in
 :mod:`fmriprep.interfaces.freesurfer.grow_mask`.
 
@@ -468,8 +469,8 @@ If FreeSurfer processing is disabled, FSL ``flirt`` is run with the
 After :abbr:`BBR (boundary-based registration)` is run, the resulting affine transform will be compared to the initial transform found by FLIRT.
 Excessive deviation will result in rejecting the BBR refinement and accepting the original, affine registration.
 
-EPI to MNI transformation
-~~~~~~~~~~~~~~~~~~~~~~~~~
+Resampling BOLD runs onto standard spaces
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 :mod:`fmriprep.workflows.bold.resampling.init_bold_std_trans_wf`
 
 .. workflow::
@@ -487,22 +488,17 @@ EPI to MNI transformation
 
 This sub-workflow concatenates the transforms calculated upstream (see
 `Head-motion estimation`_, `Susceptibility Distortion Correction (SDC)`_ --if
-fieldmaps are available--, `EPI to T1w registration`_, and a T1w-to-MNI
+fieldmaps are available--, `EPI to T1w registration`_, and an anatomical-to-standard
 transform from `T1w/T2w preprocessing`_) to map the :abbr:`EPI (echo-planar imaging)`
-image to standard MNI space.
-It also maps the T1w-based mask to MNI space.
+image to the standard spaces given by the ``--output-spaces`` argument (see
+`output_spaces`_.
+It also maps the T1w-based mask to each of those standard spaces.
 
 Transforms are concatenated and applied all at once, with one interpolation (Lanczos)
 step, so as little information is lost as possible.
 
-The output space grid can be specified using the ``template_out_grid`` argument.
-This option accepts the following (``str``) values:
-
-  * ``'native'``: the original resolution of the BOLD image will be used.
-  * ``'1mm'``: uses the 1:math:`\times`1:math:`\times`1 [mm] version of the template.
-  * ``'2mm'``: uses the 2:math:`\times`2:math:`\times`2 [mm] version of the template.
-  * **Path to arbitrary reference file**: the output will be resampled on a grid with
-    same resolution as this reference.
+The output space grid can be specified using modifiers to the ``--output-spaces``
+argument.
 
 
 EPI sampled to FreeSurfer surfaces
@@ -562,23 +558,25 @@ ICA-AROMA
 ~~~~~~~~~
 :mod:`fmriprep.workflows.bold.confounds.init_ica_aroma_wf`
 
-When one of the `--output-spaces` selected is in MNI space, ICA-AROMA denoising
-can be automatically appended to the workflow.
-The number of ICA-AROMA components depends on a dimensionality estimate made by MELODIC.
+ICA-AROMA denoising is performed in ``MNI152NLin6Asym`` space, which is automatically
+added to the list of ``--output-spaces`` if it was not already requested by the user.
+The number of ICA-AROMA components depends on a dimensionality estimate made by 
+FSL MELODIC.
 For datasets with a very short TR and a large number of timepoints, this may result
 in an unusually high number of components.
 By default, dimensionality is limited to a maximum of 200 components.
 To override this upper limit one may specify the number of components to be extracted
 with ``--aroma-melodic-dimensionality``.
-Further details on the implementation are given within the workflow generation function (:mod:`fmriprep.workflows.bold.confounds.init_ica_aroma_wf`).
+Further details on the implementation are given within the workflow generation
+function (:mod:`fmriprep.workflows.bold.confounds.init_ica_aroma_wf`).
 
 *Note*: *non*-aggressive AROMA denoising is a fundamentally different procedure
 from its "aggressive" counterpart and cannot be performed only by using a set of noise
 regressors (a separate GLM with both noise and signal regressors needs to be used).
-Therefore instead of regressors FMRIPREP produces *non*-aggressive denoised 4D NIFTI
+Therefore instead of regressors, *fMRIPrep* produces *non*-aggressive denoised 4D NIFTI
 files in the MNI space:
 
-``*bold_space-MNI152NLin2009cAsym_variant-smoothAROMAnonaggr_brainmask.nii.gz``
+``*bold_space-MNI152NLin6Asym-smoothAROMAnonaggr_brainmask.nii.gz``
 
 Additionally, the MELODIC mix and noise component indices will
 be generated, so non-aggressive denoising can be manually performed in the T1w space with ``fsl_regfilt``, *e.g.*::
diff --git a/fmriprep/workflows/bold/resampling.py b/fmriprep/workflows/bold/resampling.py
index 5e89391b2..571cc0c5c 100644
--- a/fmriprep/workflows/bold/resampling.py
+++ b/fmriprep/workflows/bold/resampling.py
@@ -177,8 +177,8 @@ def init_bold_std_trans_wf(
     use_fieldwarp=False
 ):
     """
-    This workflow samples functional images to the MNI template in a "single shot"
-    from the original BOLD series.
+    This workflow samples functional images into standard space with a single
+    resampling of the original BOLD series.
 
     .. workflow::
         :graph2use: colored

From 6444df1f142c5180c26ecb7368b292d6982e8aca Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 14:39:59 -0700
Subject: [PATCH 12/24] fix(wrapper): remove leftover ``print``.

---
 wrapper/fmriprep_docker.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wrapper/fmriprep_docker.py b/wrapper/fmriprep_docker.py
index 23a5c2c02..76c1a1073 100755
--- a/wrapper/fmriprep_docker.py
+++ b/wrapper/fmriprep_docker.py
@@ -174,7 +174,7 @@ def merge_help(wrapper_help, target_help):
     overlap = set(w_flags).intersection(t_flags)
     expected_overlap = set(['h', 'version', 'w', 'template-resampling-grid',
                             'fs-license-file', 'use-plugin'])
-    print(overlap, expected_overlap)
+
     assert overlap == expected_overlap, "Clobbering options: {}".format(
         ', '.join(overlap - expected_overlap))
 

From 625813d23820bbed533dca9f8cb13baf66e3b922 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 16:42:01 -0700
Subject: [PATCH 13/24] enh(node): remove unnecessary input setting (see
 poldracklab/niworkflows#354)

---
 fmriprep/workflows/bold/registration.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fmriprep/workflows/bold/registration.py b/fmriprep/workflows/bold/registration.py
index 827cbbe37..341ec366d 100644
--- a/fmriprep/workflows/bold/registration.py
+++ b/fmriprep/workflows/bold/registration.py
@@ -275,7 +275,7 @@ def init_bold_t1_trans_wf(freesurfer, mem_gb, omp_nthreads, multiecho=False, use
         name='outputnode'
     )
 
-    gen_ref = pe.Node(GenerateSamplingReference(keep_native=True), name='gen_ref',
+    gen_ref = pe.Node(GenerateSamplingReference(), name='gen_ref',
                       mem_gb=0.3)  # 256x256x256 * 64 / 8 ~ 150MB
 
     mask_t1w_tfm = pe.Node(

From fac9af35fef502268be304273b5b43737ba2a22d Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 21:12:20 -0700
Subject: [PATCH 14/24] fix(docs): remove MNI mentions, add cross-references

---
 docs/citing.rst    |  4 ----
 docs/usage.rst     | 12 ++++++------
 docs/workflows.rst | 14 +++++++-------
 3 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/docs/citing.rst b/docs/citing.rst
index 383e02a37..0d641cd38 100644
--- a/docs/citing.rst
+++ b/docs/citing.rst
@@ -250,10 +250,6 @@ Presentations
 Other relevant references
 -------------------------
 
-  .. [Fonov2011] Fonov VS, Evans AC, Botteron K, Almli CR, McKinstry RC, Collins DL and BDCG,
-      Unbiased average age-appropriate atlases for pediatric studies, NeuroImage 54(1), 2011
-      doi:`10.1016/j.neuroimage.2010.07.033 <https://doi.org/10.1016/j.neuroimage.2010.07.033>`_.
-
   .. [Power2017] Power JD, Plitt M, Kundu P, Bandettini PA, Martin A (2017) Temporal interpolation alters
       motion in fMRI scans: Magnitudes and consequences for artifact detection. PLOS ONE 12(9): e0182939.
       doi:`10.1371/journal.pone.0182939 <https://doi.org/10.1371/journal.pone.0182939>`_.
diff --git a/docs/usage.rst b/docs/usage.rst
index 5ad182a08..c6d820ebf 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -7,7 +7,7 @@ Usage
    As of FMRIPREP 1.0.12, the software includes a tracking system
    to report usage statistics and errors. Users can opt-out using
    the ``--notrack`` command line argument.
-   
+
 
 Execution and the BIDS format
 =============================
@@ -38,7 +38,7 @@ Command-Line Arguments
    :nodefaultconst:
 
 
-.. _output_spaces:
+.. _output-spaces:
 
 Defining standard and nonstandard spaces where data will be resampled
 =====================================================================
@@ -71,9 +71,9 @@ the original data gridding.
 However, many users will be interested in utilizing a coarse gridding (typically 2mm isotropic)
 of the target template.
 Such a behavior can be achieved applying modifiers to the template identifier, separated by
-a ``:`` character. 
+a ``:`` character.
 For instance, ``--output-spaces MNI152NLin6Asym:res-2 MNI152NLin2009cAsym`` will generate
-preprocessed BOLD 4D files on two standard spaces (``MNI152NLin6Asym``, 
+preprocessed BOLD 4D files on two standard spaces (``MNI152NLin6Asym``,
 and ``MNI152NLin2009cAsym``) with the template's 2mm isotropic resolution for
 the data on ``MNI152NLin6Asym`` space and the original BOLD resolution
 (say, e.g., 2x2x2.5 [mm]) for the case of ``MNI152NLin2009cAsym``.
@@ -116,7 +116,7 @@ Additionally, ``--output-spaces`` accepts identifiers of spatial references
 that do not generate *standardized* coordinate spaces:
 
   * ``T1w`` or ``anat``: data are resampled into the individual's anatomical
-    reference generated with the T1w and T2w images available within the 
+    reference generated with the T1w and T2w images available within the
     BIDS structure.
   * ``fsnative``: similarly to the ``anat`` space for volumetric references,
     including the ``fsnative`` space will instruct fMRIPrep to sample the
@@ -189,7 +189,7 @@ make your data available within that system first.
 
 For instance, here at the Poldrack Lab we use Stanford's
 :abbr:`HPC (high-performance computing)` system, called Sherlock.
-Sherlock enables `the following data transfer options 
+Sherlock enables `the following data transfer options
 <https://www.sherlock.stanford.edu/docs/user-guide/storage/data-transfer/>`_.
 
 Alternatively, more comprehensive solutions such as `Datalad
diff --git a/docs/workflows.rst b/docs/workflows.rst
index e9b4ab81d..3fa9dc734 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -91,7 +91,7 @@ Brain extraction, brain tissue segmentation and spatial normalization
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Then, the T1w reference is skull-stripped using a Nipype implementation of
-the ``antsBrainExtraction.sh`` tool (ANTs), which is an atlas-based 
+the ``antsBrainExtraction.sh`` tool (ANTs), which is an atlas-based
 brain extraction workflow:
 
 .. workflow::
@@ -120,7 +120,7 @@ Once the brain mask is computed, FSL ``fast`` is utilized for brain tissue segme
 
 Finally, spatial normalization to standard spaces is performed using ANTs' ``antsRegistration``
 in a multiscale, mutual-information based, nonlinear registration scheme.
-See `output_spaces`_ for information about how standard and nonstandard spaces can
+See :ref:`output-spaces` for information about how standard and nonstandard spaces can
 be set to resample the preprocessed data onto the final output spaces.
 
 
@@ -143,9 +143,9 @@ in the same space and resolution as the T1 image, and follow the naming conventi
 (e.g. ``sub-001_T1w_label-lesion_roi.nii.gz``).
 This file should be placed in the ``sub-*/anat`` directory of the BIDS dataset
 to be run through *fMRIPrep*.
-Because lesion masks are not currently part of the BIDS specification, it is also necessary to 
-include a ``.bidsignore`` file in the root of your dataset directory. This will prevent 
-`bids-validator <https://github.com/bids-standard/bids-validator#bidsignore>`_ from complaining that your dataset not BIDS valid, which prevents 
+Because lesion masks are not currently part of the BIDS specification, it is also necessary to
+include a ``.bidsignore`` file in the root of your dataset directory. This will prevent
+`bids-validator <https://github.com/bids-standard/bids-validator#bidsignore>`_ from complaining that your dataset not BIDS valid, which prevents
 *fMRIPrep* from running. Your ``.bidsignore`` file should include the following line::
 
 *lesion_roi.nii.gz
@@ -491,7 +491,7 @@ This sub-workflow concatenates the transforms calculated upstream (see
 fieldmaps are available--, `EPI to T1w registration`_, and an anatomical-to-standard
 transform from `T1w/T2w preprocessing`_) to map the :abbr:`EPI (echo-planar imaging)`
 image to the standard spaces given by the ``--output-spaces`` argument (see
-`output_spaces`_.
+:ref:`output-spaces`.
 It also maps the T1w-based mask to each of those standard spaces.
 
 Transforms are concatenated and applied all at once, with one interpolation (Lanczos)
@@ -560,7 +560,7 @@ ICA-AROMA
 
 ICA-AROMA denoising is performed in ``MNI152NLin6Asym`` space, which is automatically
 added to the list of ``--output-spaces`` if it was not already requested by the user.
-The number of ICA-AROMA components depends on a dimensionality estimate made by 
+The number of ICA-AROMA components depends on a dimensionality estimate made by
 FSL MELODIC.
 For datasets with a very short TR and a large number of timepoints, this may result
 in an unusually high number of components.

From 7e1996cb7ccf84015abeec46d5be71867b153f5b Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 21:13:08 -0700
Subject: [PATCH 15/24] enh(boilerplate): add missing reference for
 MNI152NLin6Asym

---
 fmriprep/data/boilerplate.bib | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fmriprep/data/boilerplate.bib b/fmriprep/data/boilerplate.bib
index 7e5de6299..bcf0d1107 100644
--- a/fmriprep/data/boilerplate.bib
+++ b/fmriprep/data/boilerplate.bib
@@ -100,6 +100,17 @@ @article{mni152nlin2009casym
     year = 2009
 }
 
+@article{mni152nlin6asym,
+    author = {Evans, AC and Janke, AL and Collins, DL and Baillet, S},
+    title = {Brain templates and atlases},
+    doi = {10.1016/j.neuroimage.2012.01.024},
+    journal = {NeuroImage},
+    volume = {62},
+    number = {2},
+    pages = {911--922},
+    year = 2012
+}
+
 @article{ants,
     author = {Avants, B.B. and Epstein, C.L. and Grossman, M. and Gee, J.C.},
     doi = {10.1016/j.media.2007.06.004},

From a5ca545c29c85bd8912001d6eabeacd66f8dd6b9 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 22:30:50 -0700
Subject: [PATCH 16/24] fix(--cifti-output): stick with current implementation,
 select bold_std

Leave for a future PR the implementation of HCP-compatible cifti.

Also, run a ``KeySelect`` to extract the appropriate BOLD in standard
space resampling.
---
 fmriprep/cli/run.py             |  6 +++---
 fmriprep/workflows/bold/base.py | 26 +++++++++++++++++++++-----
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/fmriprep/cli/run.py b/fmriprep/cli/run.py
index c3ec210e6..9c5cba2d7 100755
--- a/fmriprep/cli/run.py
+++ b/fmriprep/cli/run.py
@@ -684,9 +684,9 @@ def parse_spaces(opts):
 The argument "MNI152NLin6Asym:res-2" has been automatically added to the list of output spaces \
 (option ``--output-spaces``).""", file=stderr)
 
-    if opts.cifti_output and 'fsLR' not in output_spaces:
-        if 'MNI152NLin6Asym' not in output_spaces:
-            output_spaces['MNI152NLin6Asym'] = {'res': 2}
+    if opts.cifti_output and 'MNI152NLin2009cAsym' not in output_spaces:
+        if 'MNI152NLin2009cAsym' not in output_spaces:
+            output_spaces['MNI152NLin2009cAsym'] = {'res': 2}
             print("""Option ``--cifti-output`` requires functional images to be resampled to \
 ``MNI152NLin6Asym`` space. Such template identifier has been automatically added to the list \
 of output spaces (option "--output-space").""", file=stderr)
diff --git a/fmriprep/workflows/bold/base.py b/fmriprep/workflows/bold/base.py
index 03d06990e..938d68687 100755
--- a/fmriprep/workflows/bold/base.py
+++ b/fmriprep/workflows/bold/base.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """
@@ -44,7 +43,13 @@
 
 DEFAULT_MEMORY_MIN_GB = 0.01
 LOGGER = logging.getLogger('nipype.workflow')
-
+FSAVERAGE_DENSITY = {
+    '642': 'fsaverage3',
+    '2562': 'fsaverage4',
+    '10k': 'fsaverage5',
+    '41k': 'fsaverage6',
+    '164k': 'fsaverage7',
+}
 
 def init_func_preproc_wf(
     aroma_melodic_dim,
@@ -395,7 +400,10 @@ def init_func_preproc_wf(
         name='summary', mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
 
     # CIfTI output: currently, we only support fsaverage{5,6}
-    cifti_spaces = [s for s in output_spaces.keys() if s in ('fsaverage5', 'fsaverage6')]
+    cifti_spaces = set([s for s in output_spaces.keys() if s in ('fsaverage5', 'fsaverage6')])
+    fsaverage_den = output_spaces.get('fsaverage', {}).get('den')
+    if fsaverage_den:
+        cifti_spaces.add(FSAVERAGE_DENSITY[fsaverage_den])
     cifti_output = cifti_output and cifti_spaces
     func_derivatives_wf = init_func_derivatives_wf(
         bids_root=layout.root,
@@ -848,20 +856,28 @@ def init_func_preproc_wf(
         ])
 
         if cifti_output:
+            from niworkflows.interfaces.utility import KeySelect
             bold_surf_wf.__desc__ += """\
 *Grayordinates* files [@hcppipelines], which combine surface-sampled
 data and volume-sampled data, were also generated.
 """
+            select_std = pe.Node(KeySelect(fields=['bold_std']),
+                                 name='select_std', run_without_submitting=True)
+            select_std.inputs.key = 'MNI152NLin2009cAsym'
+
             gen_cifti = pe.MapNode(GenerateCifti(), iterfield=["surface_target", "gifti_files"],
                                    name="gen_cifti")
             gen_cifti.inputs.TR = metadata.get("RepetitionTime")
-            gen_cifti.inputs.surface_target = cifti_spaces
+            gen_cifti.inputs.surface_target = list(cifti_spaces)
 
             workflow.connect([
+                (bold_std_trans_wf, select_std, [
+                    ('outputnode.templates', 'keys'),
+                    ('outputnode.bold_std', 'bold_std')]),
                 (bold_surf_wf, gen_cifti, [
                     ('outputnode.surfaces', 'gifti_files')]),
                 (inputnode, gen_cifti, [('subjects_dir', 'subjects_dir')]),
-                (bold_std_trans_wf, gen_cifti, [('outputnode.bold_std', 'bold_file')]),
+                (select_std, gen_cifti, [('bold_std', 'bold_file')]),
                 (gen_cifti, outputnode, [('out_file', 'bold_cifti'),
                                          ('variant', 'cifti_variant'),
                                          ('variant_key', 'cifti_variant_key')]),

From c0ed6394574b3eb1122f0b2a8b55cc3c3d82f10e Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Tue, 30 Apr 2019 22:58:31 -0700
Subject: [PATCH 17/24] pin(smriprep,niworkflows): use commit hashes instead of
 branch names

Otherwise, it is not guaranteed that the last commit will be picked.
---
 fmriprep/__about__.py | 4 ++--
 requirements.txt      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index a996b85da..51139c0df 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -105,9 +105,9 @@
 
 LINKS_REQUIRES = [
     'git+https://github.com/poldracklab/niworkflows.git@'
-    'unstable#egg=niworkflows',
+    '0863051476f1e6999cd4a028769466e0fc6182fa#egg=niworkflows',
     'git+https://github.com/poldracklab/smriprep.git@'
-    'master#egg=smriprep-0.1.0',
+    'f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0',
 ]
 
 TESTS_REQUIRES = [
diff --git a/requirements.txt b/requirements.txt
index 4a7b11cf3..50d9870f5 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
-git+https://github.com/poldracklab/niworkflows.git@unstable#egg=niworkflows
-git+https://github.com/poldracklab/smriprep.git@master#egg=smriprep-0.1.0
+git+https://github.com/poldracklab/niworkflows.git@0863051476f1e6999cd4a028769466e0fc6182fa#egg=niworkflows
+git+https://github.com/poldracklab/smriprep.git@f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0
 templateflow<0.2.0a0,>=0.1.3

From 952693ea720e4a9aff8033fef8034990c36112bc Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Thu, 2 May 2019 20:29:47 -0700
Subject: [PATCH 18/24] fix(circle): reduce artifacts in circle and update
 output files to include MNI152NLin6Asym derivatives

---
 .circleci/config.yml                | 48 +++++++++++++++++++----------
 .circleci/ds005_outputs.txt         | 26 ++++++++++++++++
 .circleci/ds005_partial_outputs.txt | 18 +++++++++++
 3 files changed, 76 insertions(+), 16 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 369e99f17..fbf7c3595 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -462,14 +462,20 @@ jobs:
             exit $?
       - run:
           name: Clean working directory
-          when: always
+          when: on_success
           command: |
             sudo chown $(id -un):$(id -gn) -R /tmp/ds005
-            find /tmp/ds005/work -not -name "*.svg" -not -name "*.html" -not -name "*.rst" \
-                -not -name "*.mat" -not -name "*.lta" -not -name "*.json" -not -name "*.txt" -not -name "*.pklz" -type f -delete
-            find /tmp/ds005/work_partial -not -name "*.svg" -not -name "*.html" -not -name "*.rst" \
-                -not -name "*.mat" -not -name "*.lta" -not -name "*.json" -not -name "*.txt" -not -name "*.pklz" -type f -delete
-            # tar cf - work_partial/ | pigz -2 -p 2 > ds005_workdir.tar.gz && sudo rm -fr work work_partial
+            sudo rm -rf /tmp/ds005/work
+            sudo rm -rf /tmp/ds005/work_partial
+      - run:
+          name: Clean working directory
+          when: on_fail
+          command: |
+            sudo chown $(id -un):$(id -gn) -R /tmp/ds005
+            find /tmp/ds005/work \( -name "*.nii.gz" -or -name "*.nii" -or "*.gii" -or "*.h5" \) \
+                -exec sh -c 'rm -f {}; touch {}' \;
+            find /tmp/ds005/work_partial \( -name "*.nii.gz" -or -name "*.nii" -or "*.gii" -or "*.h5" \) \
+                -exec sh -c 'rm -f {}; touch {}' \;
 
       - store_artifacts:
           path: /tmp/ds005
@@ -588,13 +594,18 @@ jobs:
             set -e
             [[ "$RET" -eq "1" ]]
       - run:
-          name: Clean-up work directory
-          when: always
+          name: Clean working directory
+          when: on_success
+          command: |
+            sudo chown $(id -un):$(id -gn) -R /tmp/ds054
+            sudo rm -rf /tmp/ds054/work
+      - run:
+          name: Clean working directory
+          when: on_fail
           command: |
             sudo chown $(id -un):$(id -gn) -R /tmp/ds054
-            find /tmp/ds054/work -not -name "*.svg" -not -name "*.html" -not -name "*.rst" \
-                -not -name "*.mat" -not -name "*.lta" -not -name "*.json" -not -name "*.txt" -not -name "*.pklz" -type f -delete
-            # tar cf - work/ | pigz -2 -p 2 > ds054_workdir.tar.gz && sudo rm -fr work
+            find /tmp/ds054/work \( -name "*.nii.gz" -or -name "*.nii" -or "*.gii" -or "*.h5" \) \
+                -exec sh -c 'rm -f {}; touch {}' \;
       - store_artifacts:
           path: /tmp/ds054
 
@@ -686,13 +697,18 @@ jobs:
             diff /tmp/src/fmriprep/.circleci/ds210_outputs.txt /tmp/ds210/test/outputs.out
             exit $?
       - run:
-          name: Clean-up work directory
-          when: always
+          name: Clean working directory
+          when: on_success
+          command: |
+            sudo chown $(id -un):$(id -gn) -R /tmp/ds210
+            sudo rm -rf /tmp/ds210/work
+      - run:
+          name: Clean working directory
+          when: on_fail
           command: |
             sudo chown $(id -un):$(id -gn) -R /tmp/ds210
-            find /tmp/ds210/work -not -name "*.svg" -not -name "*.html" -not -name "*.rst" \
-                -not -name "*.mat" -not -name "*.lta" -not -name "*.json" -not -name "*.txt" -not -name "*.pklz" -type f -delete
-            # tar cf - work/ | pigz -2 -p 2 > ds054_workdir.tar.gz && sudo rm -fr work
+            find /tmp/ds210/work \( -name "*.nii.gz" -or -name "*.nii" -or "*.gii" -or "*.h5" \) \
+                -exec sh -c 'rm -f {}; touch {}' \;
       - store_artifacts:
           path: /tmp/ds210
 
diff --git a/.circleci/ds005_outputs.txt b/.circleci/ds005_outputs.txt
index 493b13342..18d51e6c7 100644
--- a/.circleci/ds005_outputs.txt
+++ b/.circleci/ds005_outputs.txt
@@ -17,9 +17,11 @@ fmriprep/sub-01/anat/sub-01_desc-preproc_T1w.json
 fmriprep/sub-01/anat/sub-01_desc-preproc_T1w.nii.gz
 fmriprep/sub-01/anat/sub-01_dseg.nii.gz
 fmriprep/sub-01/anat/sub-01_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5
+fmriprep/sub-01/anat/sub-01_from-MNI152NLin6Asym_to-T1w_mode-image_xfm.h5
 fmriprep/sub-01/anat/sub-01_from-orig_to-T1w_mode-image_xfm.txt
 fmriprep/sub-01/anat/sub-01_from-T1w_to-fsnative_mode-image_xfm.txt
 fmriprep/sub-01/anat/sub-01_from-T1w_to-MNI152NLin2009cAsym_mode-image_xfm.h5
+fmriprep/sub-01/anat/sub-01_from-T1w_to-MNI152NLin6Asym_mode-image_xfm.h5
 fmriprep/sub-01/anat/sub-01_hemi-L_inflated.surf.gii
 fmriprep/sub-01/anat/sub-01_hemi-L_midthickness.surf.gii
 fmriprep/sub-01/anat/sub-01_hemi-L_pial.surf.gii
@@ -39,6 +41,14 @@ fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_dseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-CSF_probseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-GM_probseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-WM_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-brain_mask.json
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-brain_mask.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.json
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_dseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-CSF_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-GM_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-WM_probseg.nii.gz
 fmriprep/sub-01/func
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_AROMAnoiseICs.csv
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_bold.dtseries.json
@@ -57,6 +67,14 @@ fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin2009cAs
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin2009cAsym_desc-preproc_bold.json
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin2009cAsym_desc-smoothAROMAnonaggr_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_boldref.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-aparcaseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-aseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-brain_mask.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-brain_mask.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-preproc_bold.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-preproc_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-MNI152NLin6Asym_desc-smoothAROMAnonaggr_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-T1w_boldref.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-T1w_desc-aparcaseg_dseg.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-01_space-T1w_desc-aseg_dseg.nii.gz
@@ -81,6 +99,14 @@ fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAs
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-preproc_bold.json
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-smoothAROMAnonaggr_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_boldref.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-aparcaseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-aseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-brain_mask.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-brain_mask.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-preproc_bold.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-preproc_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-smoothAROMAnonaggr_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_boldref.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_desc-aparcaseg_dseg.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_desc-aseg_dseg.nii.gz
diff --git a/.circleci/ds005_partial_outputs.txt b/.circleci/ds005_partial_outputs.txt
index 9f04d01ac..740930cbf 100644
--- a/.circleci/ds005_partial_outputs.txt
+++ b/.circleci/ds005_partial_outputs.txt
@@ -17,9 +17,11 @@ fmriprep/sub-01/anat/sub-01_desc-preproc_T1w.json
 fmriprep/sub-01/anat/sub-01_desc-preproc_T1w.nii.gz
 fmriprep/sub-01/anat/sub-01_dseg.nii.gz
 fmriprep/sub-01/anat/sub-01_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5
+fmriprep/sub-01/anat/sub-01_from-MNI152NLin6Asym_to-T1w_mode-image_xfm.h5
 fmriprep/sub-01/anat/sub-01_from-orig_to-T1w_mode-image_xfm.txt
 fmriprep/sub-01/anat/sub-01_from-T1w_to-fsnative_mode-image_xfm.txt
 fmriprep/sub-01/anat/sub-01_from-T1w_to-MNI152NLin2009cAsym_mode-image_xfm.h5
+fmriprep/sub-01/anat/sub-01_from-T1w_to-MNI152NLin6Asym_mode-image_xfm.h5
 fmriprep/sub-01/anat/sub-01_hemi-L_inflated.surf.gii
 fmriprep/sub-01/anat/sub-01_hemi-L_midthickness.surf.gii
 fmriprep/sub-01/anat/sub-01_hemi-L_pial.surf.gii
@@ -39,6 +41,14 @@ fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_dseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-CSF_probseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-GM_probseg.nii.gz
 fmriprep/sub-01/anat/sub-01_space-MNI152NLin2009cAsym_label-WM_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-brain_mask.json
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-brain_mask.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.json
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_dseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-CSF_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-GM_probseg.nii.gz
+fmriprep/sub-01/anat/sub-01_space-MNI152NLin6Asym_label-WM_probseg.nii.gz
 fmriprep/sub-01/func
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_AROMAnoiseICs.csv
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_bold.dtseries.json
@@ -57,6 +67,14 @@ fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAs
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-preproc_bold.json
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin2009cAsym_desc-smoothAROMAnonaggr_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_boldref.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-aparcaseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-aseg_dseg.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-brain_mask.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-brain_mask.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-preproc_bold.json
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-preproc_bold.nii.gz
+fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-MNI152NLin6Asym_desc-smoothAROMAnonaggr_bold.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_boldref.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_desc-aparcaseg_dseg.nii.gz
 fmriprep/sub-01/func/sub-01_task-mixedgamblestask_run-02_space-T1w_desc-aseg_dseg.nii.gz

From ffb3483e0f8e46784a004deb01a95c69fa8d1869 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Thu, 2 May 2019 20:36:36 -0700
Subject: [PATCH 19/24] pin(niworkflows): set latest commit @ unstable branch

---
 fmriprep/__about__.py | 5 ++---
 requirements.txt      | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index 26cc825b4..27fca0ad0 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """
@@ -104,8 +103,8 @@
 
 
 LINKS_REQUIRES = [
-    'git+https://github.com/oesteban/niworkflows.git@'
-    'c37dda4b7ab28fa8dd6c2136b20721310dd3e91d#egg=niworkflows',
+    'git+https://github.com/poldracklab/niworkflows.git@'
+    '121ab5df2988d794f915c595ae4bc6dc8259ba2a#egg=niworkflows',
     'git+https://github.com/poldracklab/smriprep.git@'
     'f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0',
 ]
diff --git a/requirements.txt b/requirements.txt
index 7ce2107ab..b2ab1141c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
-git+https://github.com/oesteban/niworkflows.git@c37dda4b7ab28fa8dd6c2136b20721310dd3e91d#egg=niworkflows
+git+https://github.com/poldracklab/niworkflows.git@121ab5df2988d794f915c595ae4bc6dc8259ba2a#egg=niworkflows
 git+https://github.com/poldracklab/smriprep.git@f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0
 templateflow<0.2.0a0,>=0.1.3

From 58b8865f718a0ba9ea09fac4f6cc9f271a66d36f Mon Sep 17 00:00:00 2001
From: Chris Markiewicz <effigies@gmail.com>
Date: Fri, 3 May 2019 08:37:57 -0700
Subject: [PATCH 20/24] [skip ci] Apply suggestions from code review

Co-Authored-By: oesteban <code@oscaresteban.es>
---
 docs/usage.rst                  | 4 ++--
 docs/workflows.rst              | 7 ++++---
 fmriprep/workflows/bold/base.py | 2 +-
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/docs/usage.rst b/docs/usage.rst
index c6d820ebf..621a61f7b 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -86,7 +86,7 @@ Therefore, in upcoming versions of fMRIPrep, it will be possible to run it with
 ``--output-spaces MNIPediatricAsym:res-2:cohort-2`` where ``cohort-2`` would select
 the template instance for the, say, 24-48 months old range.
 
-When specifying surface spaces (e.g. ``fsaverage``), the legacy identifiers from
+When specifying surface spaces (e.g., ``fsaverage``), the legacy identifiers from
 FreeSurfer will be supported (e.g. ``fsaverage5``) although the use of the density
 modifier would be preferred (i.e. ``fsaverage:den-10k`` for ``fsaverage5``).
 
@@ -132,7 +132,7 @@ Preprocessing blocks depending on standard templates
 
 Some modules of the pipeline (e.g. the ICA-AROMA denoising, the generation of
 HCP compatible *grayordinates* files, or the *fieldmap-less* distortion correction)
-perform on specific template spaces.
+operate in specific template spaces.
 When selecting those modules to be included (using any of the following flags:
 ``--use-aroma``, ``--cifti-outputs``, ``--use-syn-sdc``) will modify the list of
 output spaces to include the space identifiers they require, should the
diff --git a/docs/workflows.rst b/docs/workflows.rst
index 7816c3046..4a781e6e0 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -146,8 +146,9 @@ This file should be placed in the ``sub-*/anat`` directory of the BIDS dataset
 to be run through *fMRIPrep*.
 Because lesion masks are not currently part of the BIDS specification, it is also necessary to
 include a ``.bidsignore`` file in the root of your dataset directory. This will prevent
-`bids-validator <https://github.com/bids-standard/bids-validator#bidsignore>`_ from complaining that your dataset not BIDS valid, which prevents
-*fMRIPrep* from running. Your ``.bidsignore`` file should include the following line::
+`bids-validator <https://github.com/bids-standard/bids-validator#bidsignore>`_ from complaining
+that your dataset is not valid BIDS, which prevents *fMRIPrep* from running.
+Your ``.bidsignore`` file should include the following line::
 
 *lesion_roi.nii.gz
 
@@ -577,7 +578,7 @@ regressors (a separate GLM with both noise and signal regressors needs to be use
 Therefore instead of regressors, *fMRIPrep* produces *non*-aggressive denoised 4D NIFTI
 files in the MNI space:
 
-``*bold_space-MNI152NLin6Asym-smoothAROMAnonaggr_brainmask.nii.gz``
+``*bold_space-MNI152NLin6Asym_desc-smoothAROMAnonaggr_brainmask.nii.gz``
 
 Additionally, the MELODIC mix and noise component indices will
 be generated, so non-aggressive denoising can be manually performed in the T1w space with ``fsl_regfilt``, *e.g.*::
diff --git a/fmriprep/workflows/bold/base.py b/fmriprep/workflows/bold/base.py
index 18c878cc6..9652644ba 100755
--- a/fmriprep/workflows/bold/base.py
+++ b/fmriprep/workflows/bold/base.py
@@ -401,7 +401,7 @@ def init_func_preproc_wf(
         name='summary', mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
 
     # CIfTI output: currently, we only support fsaverage{5,6}
-    cifti_spaces = set([s for s in output_spaces.keys() if s in ('fsaverage5', 'fsaverage6')])
+    cifti_spaces = set(s for s in output_spaces.keys() if s in ('fsaverage5', 'fsaverage6'))
     fsaverage_den = output_spaces.get('fsaverage', {}).get('den')
     if fsaverage_den:
         cifti_spaces.add(FSAVERAGE_DENSITY[fsaverage_den])

From f1113df11e9769b83dd23e345906e0f1866f6be8 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Fri, 3 May 2019 09:08:55 -0700
Subject: [PATCH 21/24] fix(@effigies' review): address several comments not
 deferred to docs/revise-1596

---
 fmriprep/cli/run.py             | 22 +++++++++++-----------
 fmriprep/interfaces/reports.py  | 14 ++++++--------
 fmriprep/workflows/base.py      |  6 ++++--
 fmriprep/workflows/bold/base.py | 12 ++++++------
 4 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/fmriprep/cli/run.py b/fmriprep/cli/run.py
index 71193db02..71c77535f 100755
--- a/fmriprep/cli/run.py
+++ b/fmriprep/cli/run.py
@@ -130,14 +130,14 @@ def get_parser():
     g_conf.add_argument(
         '--output-spaces', nargs='+', action=ParseTemplates,
         help="""\
-Paths or keywords prescribing standard spaces to which normalize the input T1w image \
-and nonstandard spaces in which BOLD runs will be resampled (valid keywords are: \
-%s and paths poing to templates) with modifiers (optional parameters).
-Output spaces may be templates with modifiers or dataset-specific references. \
-Templates take the form ``<TEMPLATE>[:res-<resolution>][:cohort-<label>][...]``,  \
-with optional, colon-separated parameters, while dataset-specific references imply \
-a specific orientation and sampling grid.\
-""" % ', '.join('"%s"' % s for s in templates() + NONSTANDARD_REFERENCES))
+Standard and non-standard spaces to resample anatomical and functional images to. \
+Standard spaces may be specified by the form \
+``<TEMPLATE>[:res-<resolution>][:cohort-<label>][...]``, where ``<TEMPLATE>`` is \
+a keyword (valid keywords: %s) or path pointing to a user-supplied template, and \
+may be followed by optional, colon-separated parameters. \
+Non-standard spaces (valid keywords: %s) imply specific orientations and sampling \
+grids""" % (', '.join('"%s"' % s for s in templates()),
+            ', '.join(NONSTANDARD_REFERENCES)))
 
     g_conf.add_argument(
         '--output-space', required=False, action='store', type=str, nargs='+',
@@ -209,7 +209,7 @@ def get_parser():
     # FreeSurfer options
     g_fs = parser.add_argument_group('Specific options for FreeSurfer preprocessing')
     g_fs.add_argument(
-        '--fs-license-file', type=Path,
+        '--fs-license-file', metavar='PATH', type=Path,
         help='Path to FreeSurfer license key file. Get it (for free) by registering'
              ' at https://surfer.nmr.mgh.harvard.edu/registration.html')
 
@@ -688,8 +688,8 @@ def parse_spaces(opts):
         if 'MNI152NLin2009cAsym' not in output_spaces:
             output_spaces['MNI152NLin2009cAsym'] = {'res': 2}
             print("""Option ``--cifti-output`` requires functional images to be resampled to \
-``MNI152NLin6Asym`` space. Such template identifier has been automatically added to the list \
-of output spaces (option "--output-space").""", file=stderr)
+``MNI152NLin2009cAsym`` space. Such template identifier has been automatically added to the \
+list of output spaces (option "--output-space").""", file=stderr)
         if not [s for s in output_spaces if s in ('fsaverage5', 'fsaverage6')]:
             output_spaces['fsaverage5'] = {}
             print("""Option ``--cifti-output`` requires functional images to be resampled to \
diff --git a/fmriprep/interfaces/reports.py b/fmriprep/interfaces/reports.py
index 7637d66f0..82d10cfeb 100644
--- a/fmriprep/interfaces/reports.py
+++ b/fmriprep/interfaces/reports.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """
@@ -28,7 +26,8 @@
 \t\t<li>Structural images: {n_t1s:d} T1-weighted {t2w}</li>
 \t\t<li>Functional series: {n_bold:d}</li>
 {tasks}
-\t\t<li>Standard output spaces: {output_spaces}</li>
+\t\t<li>Standard output spaces: {std_spaces}</li>
+\t\t<li>Non-standard output spaces: {nstd_spaces}</li>
 \t\t<li>FreeSurfer reconstruction: {freesurfer_status}</li>
 \t</ul>
 """
@@ -40,7 +39,6 @@
 \t\t\t<li>Slice timing correction: {stc}</li>
 \t\t\t<li>Susceptibility distortion correction: {sdc}</li>
 \t\t\t<li>Registration: {registration}</li>
-\t\t\t<li>Functional series resampled to spaces: {output_spaces}</li>
 \t\t\t<li>Confounds collected: {confounds}</li>
 \t\t</ul>
 """
@@ -81,7 +79,8 @@ class SubjectSummaryInputSpec(BaseInterfaceInputSpec):
     bold = InputMultiObject(traits.Either(
         File(exists=True), traits.List(File(exists=True))),
         desc='BOLD functional series')
-    output_spaces = InputMultiObject(Str, desc='list of standard spaces')
+    std_spaces = InputMultiObject(Str, desc='list of standard spaces')
+    nstd_spaces = InputMultiObject(Str, desc='list of non-standard spaces')
 
 
 class SubjectSummaryOutputSpec(SummaryOutputSpec):
@@ -138,7 +137,8 @@ def _generate_segment(self):
             t2w=t2w_seg,
             n_bold=len(bold_series),
             tasks=tasks,
-            output_spaces=', '.join(self.inputs.output_spaces),
+            std_spaces=', '.join(self.inputs.std_spaces),
+            nstd_spaces=', '.join(self.inputs.nstd_spaces),
             freesurfer_status=freesurfer_status)
 
 
@@ -154,7 +154,6 @@ class FunctionalSummaryInputSpec(BaseInterfaceInputSpec):
     fallback = traits.Bool(desc='Boundary-based registration rejected')
     registration_dof = traits.Enum(6, 9, 12, desc='Registration degrees of freedom',
                                    mandatory=True)
-    output_spaces = traits.List(desc='Target spaces')
     confounds_file = File(exists=True, desc='Confounds file')
     tr = traits.Float(desc='Repetition time', mandatory=True)
 
@@ -187,7 +186,6 @@ def _generate_segment(self):
                 conflist = cfh.readline().strip('\n').strip()
         return FUNCTIONAL_TEMPLATE.format(
             pedir=pedir, stc=stc, sdc=self.inputs.distortion_correction, registration=reg,
-            output_spaces=', '.join(self.inputs.output_spaces),
             confounds=re.sub(r'[\t ]+', ', ', conflist), tr=self.inputs.tr)
 
 
diff --git a/fmriprep/workflows/base.py b/fmriprep/workflows/base.py
index efb57097c..ea6b35f0a 100755
--- a/fmriprep/workflows/base.py
+++ b/fmriprep/workflows/base.py
@@ -475,8 +475,10 @@ def init_single_subject_wf(
     bids_info = pe.Node(BIDSInfo(
         bids_dir=layout.root, bids_validate=False), name='bids_info')
 
-    summary = pe.Node(SubjectSummary(output_spaces=list(std_spaces.keys())),
-                      name='summary', run_without_submitting=True)
+    summary = pe.Node(SubjectSummary(
+        std_spaces=list(std_spaces.keys()),
+        nstd_spaces=list(set(NONSTANDARD_REFERENCES).intersection(output_spaces.keys()))),
+        name='summary', run_without_submitting=True)
 
     about = pe.Node(AboutSummary(version=__version__,
                                  command=' '.join(sys.argv)),
diff --git a/fmriprep/workflows/bold/base.py b/fmriprep/workflows/bold/base.py
index 9652644ba..14843e1e3 100755
--- a/fmriprep/workflows/bold/base.py
+++ b/fmriprep/workflows/bold/base.py
@@ -392,12 +392,12 @@ def init_func_preproc_wf(
     boldbuffer = pe.Node(niu.IdentityInterface(fields=['bold_file']), name='boldbuffer')
 
     summary = pe.Node(
-        FunctionalSummary(output_spaces=list(output_spaces.keys()),
-                          slice_timing=run_stc,
-                          registration='FreeSurfer' if freesurfer else 'FSL',
-                          registration_dof=bold2t1w_dof,
-                          pe_direction=metadata.get("PhaseEncodingDirection"),
-                          tr=metadata.get("RepetitionTime")),
+        FunctionalSummary(
+            slice_timing=run_stc,
+            registration='FreeSurfer' if freesurfer else 'FSL',
+            registration_dof=bold2t1w_dof,
+            pe_direction=metadata.get("PhaseEncodingDirection"),
+            tr=metadata.get("RepetitionTime")),
         name='summary', mem_gb=DEFAULT_MEMORY_MIN_GB, run_without_submitting=True)
 
     # CIfTI output: currently, we only support fsaverage{5,6}

From 695dd03ff016ed1ee7296c479dce7e2b18fd010d Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Fri, 3 May 2019 11:11:10 -0700
Subject: [PATCH 22/24] pin(niworkflows): 0.9.0

---
 docs/environment.yml  | 2 +-
 fmriprep/__about__.py | 4 +---
 requirements.txt      | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/docs/environment.yml b/docs/environment.yml
index 6f73a1c15..ff1cdd379 100644
--- a/docs/environment.yml
+++ b/docs/environment.yml
@@ -28,6 +28,6 @@ dependencies:
     - svgutils
     - nitime
     - nilearn!=0.5.0,!=0.5.1
-    - niworkflows<0.9.0a0,>=0.8.1
+    - niworkflows<0.10.0a0,>=0.9.0
     - smriprep
     - tedana>=0.0.5
diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index 27fca0ad0..f38c88b49 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -88,7 +88,7 @@
     'nilearn!=0.5.0,!=0.5.1',
     'nipype>=1.1.6',
     'nitime',
-    'niworkflows',
+    'niworkflows<0.10.0a0,>=0.9.0',
     'numpy',
     'pandas',
     'psutil>=5.4',
@@ -103,8 +103,6 @@
 
 
 LINKS_REQUIRES = [
-    'git+https://github.com/poldracklab/niworkflows.git@'
-    '121ab5df2988d794f915c595ae4bc6dc8259ba2a#egg=niworkflows',
     'git+https://github.com/poldracklab/smriprep.git@'
     'f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0',
 ]
diff --git a/requirements.txt b/requirements.txt
index b2ab1141c..2d4f66c46 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
-git+https://github.com/poldracklab/niworkflows.git@121ab5df2988d794f915c595ae4bc6dc8259ba2a#egg=niworkflows
+niworkflows<0.10.0a0,>=0.9.0
 git+https://github.com/poldracklab/smriprep.git@f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0
 templateflow<0.2.0a0,>=0.1.3

From 17fae3cac4bbde3258076a5bbd402983230d0231 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Fri, 3 May 2019 12:02:54 -0700
Subject: [PATCH 23/24] fix(interface): do not flatten input to
 ``SubjectSummary`` interface

---
 fmriprep/interfaces/reports.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fmriprep/interfaces/reports.py b/fmriprep/interfaces/reports.py
index 82d10cfeb..354feb76c 100644
--- a/fmriprep/interfaces/reports.py
+++ b/fmriprep/interfaces/reports.py
@@ -79,8 +79,8 @@ class SubjectSummaryInputSpec(BaseInterfaceInputSpec):
     bold = InputMultiObject(traits.Either(
         File(exists=True), traits.List(File(exists=True))),
         desc='BOLD functional series')
-    std_spaces = InputMultiObject(Str, desc='list of standard spaces')
-    nstd_spaces = InputMultiObject(Str, desc='list of non-standard spaces')
+    std_spaces = traits.List(Str, desc='list of standard spaces')
+    nstd_spaces = traits.List(Str, desc='list of non-standard spaces')
 
 
 class SubjectSummaryOutputSpec(SummaryOutputSpec):

From b4832dd86670c625ae1a58fdaee093fd06b436f9 Mon Sep 17 00:00:00 2001
From: oesteban <code@oscaresteban.es>
Date: Fri, 3 May 2019 14:01:41 -0700
Subject: [PATCH 24/24] pin(smriprep): to 0.2.0, which just posted [skip ci]

---
 docs/environment.yml  | 2 +-
 fmriprep/__about__.py | 4 +---
 requirements.txt      | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/docs/environment.yml b/docs/environment.yml
index ff1cdd379..8f8d47930 100644
--- a/docs/environment.yml
+++ b/docs/environment.yml
@@ -29,5 +29,5 @@ dependencies:
     - nitime
     - nilearn!=0.5.0,!=0.5.1
     - niworkflows<0.10.0a0,>=0.9.0
-    - smriprep
+    - smriprep<0.3.0a0,>=0.2.0
     - tedana>=0.0.5
diff --git a/fmriprep/__about__.py b/fmriprep/__about__.py
index f38c88b49..14603b181 100644
--- a/fmriprep/__about__.py
+++ b/fmriprep/__about__.py
@@ -95,7 +95,7 @@
     'pybids<0.8.0a0,>=0.7.1',
     'pyyaml',
     'scikit-image',
-    'smriprep',
+    'smriprep<0.3.0a0,>=0.2.0',
     'statsmodels',
     'tedana>=0.0.5',
     'templateflow<0.2.0a0,>=0.1.3',
@@ -103,8 +103,6 @@
 
 
 LINKS_REQUIRES = [
-    'git+https://github.com/poldracklab/smriprep.git@'
-    'f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0',
 ]
 
 TESTS_REQUIRES = [
diff --git a/requirements.txt b/requirements.txt
index 2d4f66c46..e7569f8c1 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 nilearn!=0.5.0,!=0.5.1
 niworkflows<0.10.0a0,>=0.9.0
-git+https://github.com/poldracklab/smriprep.git@f1cfc37bcdc346549dbf1d037cdade3a3b32d5de#egg=smriprep-0.1.0
+smriprep<0.3.0a0,>=0.2.0
 templateflow<0.2.0a0,>=0.1.3