From 9874e636488ff78eace1ea6fcf590adeeebcd8dd Mon Sep 17 00:00:00 2001
From: Taylor Salo <salot@pennmedicine.upenn.edu>
Date: Sat, 28 Sep 2024 08:28:42 -0400
Subject: [PATCH] Replace restricted confound sets with config files (#1255)

---
 .circleci/config.yml                          |  41 +-
 docs/outputs.rst                              |   7 +-
 docs/usage.rst                                | 108 ++-
 docs/workflows.rst                            | 146 +++-
 xcp_d/cli/parser.py                           | 102 ++-
 xcp_d/cli/parser_utils.py                     |  49 ++
 xcp_d/cli/run.py                              |   1 -
 xcp_d/cli/workflow.py                         |  17 +-
 xcp_d/config.py                               |  17 +-
 xcp_d/data/nuisance/24P.yml                   |  44 +
 xcp_d/data/nuisance/27P.yml                   |  48 ++
 xcp_d/data/nuisance/36P.yml                   |  57 ++
 xcp_d/data/nuisance/acompcor.yml              |  38 +
 xcp_d/data/nuisance/acompcor_gsr.yml          |  42 +
 xcp_d/data/nuisance/aroma.yml                 |  33 +
 xcp_d/data/nuisance/aroma_gsr.yml             |  33 +
 xcp_d/data/nuisance/gsr_only.yml              |  17 +
 xcp_d/data/nuisance/rapidtide+24P.yml         |  53 ++
 xcp_d/data/tests/config.toml                  |   6 +-
 xcp_d/interfaces/censoring.py                 | 766 ++++++++++++------
 xcp_d/interfaces/concatenation.py             |  37 +-
 xcp_d/interfaces/nilearn.py                   |  35 +-
 xcp_d/interfaces/plotting.py                  |  44 +-
 xcp_d/interfaces/utils.py                     |  31 +-
 xcp_d/tests/conftest.py                       |  36 +-
 xcp_d/tests/data/ds001419_nifti_filter.json   |   2 +-
 .../data/test_ds001419_cifti_outputs.txt      |  26 +-
 .../data/test_ds001419_nifti_outputs.txt      |  92 +--
 xcp_d/tests/data/test_pnc_cifti_outputs.txt   |   4 +-
 .../data/test_pnc_cifti_t2wonly_outputs.txt   |   4 +-
 xcp_d/tests/data/test_ukbiobank_outputs.txt   |   4 +-
 xcp_d/tests/test_TR.py                        | 195 -----
 xcp_d/tests/test_cli.py                       |  60 +-
 xcp_d/tests/test_cli_run.py                   |  39 +-
 xcp_d/tests/test_interfaces_censoring.py      | 425 +++++++++-
 xcp_d/tests/test_interfaces_concatenation.py  |  26 +-
 xcp_d/tests/test_interfaces_nilearn.py        |  26 +-
 xcp_d/tests/test_utils_bids.py                |  40 +-
 xcp_d/tests/test_utils_boilerplate.py         | 128 +--
 xcp_d/tests/test_utils_confounds.py           | 158 +---
 xcp_d/tests/test_utils_execsummary.py         |   2 +-
 xcp_d/tests/test_utils_plotting.py            |   8 +-
 xcp_d/tests/test_utils_utils.py               |  72 +-
 xcp_d/tests/test_utils_write_save.py          |   2 +-
 xcp_d/tests/utils.py                          |  19 +-
 xcp_d/utils/bids.py                           | 205 ++++-
 xcp_d/utils/boilerplate.py                    | 146 +---
 xcp_d/utils/confounds.py                      | 296 +------
 xcp_d/utils/doc.py                            |  15 +-
 xcp_d/utils/modified_data.py                  |  23 +-
 xcp_d/utils/plotting.py                       |  11 +-
 xcp_d/workflows/base.py                       |  18 +-
 xcp_d/workflows/bold/cifti.py                 |  60 +-
 xcp_d/workflows/bold/concatenation.py         |  28 +-
 xcp_d/workflows/bold/connectivity.py          |   6 +-
 xcp_d/workflows/bold/nifti.py                 |  63 +-
 xcp_d/workflows/bold/outputs.py               |  63 +-
 xcp_d/workflows/bold/plotting.py              |  16 +-
 xcp_d/workflows/bold/postprocessing.py        | 182 +++--
 59 files changed, 2437 insertions(+), 1835 deletions(-)
 create mode 100644 xcp_d/data/nuisance/24P.yml
 create mode 100644 xcp_d/data/nuisance/27P.yml
 create mode 100644 xcp_d/data/nuisance/36P.yml
 create mode 100644 xcp_d/data/nuisance/acompcor.yml
 create mode 100644 xcp_d/data/nuisance/acompcor_gsr.yml
 create mode 100644 xcp_d/data/nuisance/aroma.yml
 create mode 100644 xcp_d/data/nuisance/aroma_gsr.yml
 create mode 100644 xcp_d/data/nuisance/gsr_only.yml
 create mode 100644 xcp_d/data/nuisance/rapidtide+24P.yml
 delete mode 100644 xcp_d/tests/test_TR.py

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 8d9a23be6..63d28e08a 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -40,21 +40,38 @@ jobs:
     steps:
       - checkout
       - restore_cache:
-          key: ds001419-fmriprep-08
+          key: ds001419-10
       - run: *runinstall
       - run:
-          name: Download ds001419-fmriprep test data
+          name: Download ds001419 fMRIPrep test data
           command: |
             cd /src/xcp_d/.circleci
             python get_data.py $PWD/data ds001419
       - save_cache:
-          key: ds001419-fmriprep-08
+          key: ds001419-10
           paths:
-            - /src/xcp_d/.circleci/data/ds001419-fmriprep
+            - /src/xcp_d/.circleci/data/ds001419
     # The resource_class feature allows configuring CPU and RAM resources for each job. Different resource classes are available for different executors. https://circleci.com/docs/2.0/configuration-reference/#resourceclass
     # Why do we need a big executor for this job?
     resource_class: large
 
+  download_data_ds001419_aroma:
+    <<: *dockersetup
+    steps:
+      - checkout
+      - restore_cache:
+          key: ds001419-aroma-02
+      - run: *runinstall
+      - run:
+          name: Download ds001419 fMRIPost-AROMA test data
+          command: |
+            cd /src/xcp_d/.circleci
+            python get_data.py $PWD/data ds001419-aroma
+      - save_cache:
+          key: ds001419-aroma-02
+          paths:
+            - /src/xcp_d/.circleci/data/ds001419-aroma
+
   download_data_pnc:
     <<: *dockersetup
     steps:
@@ -227,7 +244,9 @@ jobs:
               circleci step halt
             fi
       - restore_cache:
-          key: ds001419-fmriprep-08
+          key: ds001419-10
+      - restore_cache:
+          key: ds001419-aroma-02
       - run: *runinstall
       - run:
           name: Run full xcp_d on nifti with freesurfer
@@ -269,7 +288,7 @@ jobs:
               circleci step halt
             fi
       - restore_cache:
-          key: ds001419-fmriprep-08
+          key: ds001419-10
       - run: *runinstall
       - run:
           name: Run full xcp_d on cifti with freesurfer
@@ -481,7 +500,7 @@ jobs:
       - restore_cache:
           key: pnc-02
       - restore_cache:
-          key: ds001419-fmriprep-08
+          key: ds001419-10
       - restore_cache:
           key: fmriprepwithoutfreesurfer-03
       - restore_cache:
@@ -594,6 +613,13 @@ workflows:
             tags:
               only: /.*/
 
+      - download_data_ds001419_aroma:
+          requires:
+            - build
+          filters:
+            tags:
+              only: /.*/
+
       - download_data_pnc:
           requires:
             - build
@@ -658,6 +684,7 @@ workflows:
       - ds001419_nifti:
           requires:
             - download_data_ds001419
+            - download_data_ds001419_aroma
           filters:
             branches:
               ignore:
diff --git a/docs/outputs.rst b/docs/outputs.rst
index 9baab309b..98f086068 100644
--- a/docs/outputs.rst
+++ b/docs/outputs.rst
@@ -315,14 +315,15 @@ Other outputs include quality control, framewise displacement, and confounds fil
 
       sub-<label>/[ses-<label>/]
          func/
-            <source_entities>[_desc-filtered]_motion.tsv
+            <source_entities>_motion.tsv
             <source_entities>_outliers.tsv
             <source_entities>_design.tsv
             <source_entities>_space-<label>_desc-linc_qc.tsv
 
-``[desc-filtered]_motion.tsv`` is a tab-delimited file with seven columns:
+``_motion.tsv`` is a tab-delimited file with seven columns:
 one for each of the six filtered motion parameters, as well as "framewise_displacement".
-If no motion filtering was applied, this file will not have the ``desc-filtered`` entity.
+If motion filtering was applied, this file will seven extra columns: the seven described above,
+with ``_filtered`` appended to each column.
 This file includes the high-motion volumes that are removed in most other derivatives.
 
 ``outliers.tsv`` is a tab-delimited file with one column: "framewise_displacement".
diff --git a/docs/usage.rst b/docs/usage.rst
index 53911ebb9..f71409330 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -370,38 +370,39 @@ Therefore, once a user specifies the container options and the image to be run,
 the command line options are the same as the *bare-metal* installation.
 
 
-.. _usage_custom_confounds:
-
 ****************
 Custom Confounds
 ****************
 
-XCP-D can include custom confounds in its denoising.
-Here, you can supply your confounds, and optionally add these to a confound strategy already
-supported in XCP-D.
-
-To add custom confounds to your workflow, use the ``--custom-confounds`` parameter,
-and provide a folder containing the custom confounds files for all of the subjects, sessions, and
-tasks you plan to post-process.
+If you would like to denoise your data with confounds that are not included in the built-in
+confound strategies, you can create your own.
+Please see :ref:`confound_config` for more info on the configuration file format.
 
-The individual confounds files should be tab-delimited, with one column for each regressor,
-and one row for each volume in the data being denoised.
+If you have a set of custom confounds that you would like to use, you need to organize them into a
+BIDS dataset.
+The dataset should only require the actual confound files, preferably with associated sidecar
+JSONs, and a ``dataset_description.json`` file.
+Using the same filenames as the fMRIPrep confound files is an easy way to organize this dataset.
 
 
 Including Signal Regressors
 ===========================
 
+.. warning::
+   Signal regressors are not currently supported in combination with voxel-wise regressors.
+
+.. warning::
+   Please be careful when including signal regressors.
+   Most of the time this is probably a bad idea.
+   For example, if you run tedana, only noise components from tedana should be orthogonalized
+   with respect to signal components.
+   You wouldn't want to orthogonalize other noise signals (e.g., motion parameters) with respect
+   to the signal components from tedana.
+
 Let's say you have some nuisance regressors that are not necessarily orthogonal to some associated
 regressors that are ostensibly signal.
-For example, if you ran `tedana <https://tedana.readthedocs.io/en/stable/>`_ on multi-echo data,
-you would have a series of "rejected" (noise) and "accepted" (signal) ICA components.
-Because tedana uses a spatial ICA, these components' time series are not necessarily independent,
-and there can be shared variance between them.
-If you want to properly denoise your data using the noise components,
-you need to account for the variance they share with the signal components.
-
-XCP-D allows users to include the signal regressors in their custom confounds file,
-so that the noise regressors can be orthogonalized with respect to the signal regressors.
+For example, if you want to denoise your data while still retaining task signal,
+you could include the predicted task signals in your confounds.
 
 For more information about different types of denoising,
 see `tedana's documentation <https://tedana.readthedocs.io/en/latest/denoising.html>`_,
@@ -415,23 +416,18 @@ them without modification,
 you should include those regressors in your custom confounds file,
 with column names starting with ``signal__`` (lower-case "signal", followed by two underscores).
 
-.. important::
-
-   XCP-D will automatically orthogonalize noise regressors with respect to signal regressors
-   with any nuisance-regressor option that uses AROMA regressors (e.g., ``aroma`` or ``aroma_gsr``).
-
 
 Task Regression
 ===============
 
-If you want to regress task-related signals out of your data, you can use the custom confounds
-option to do it.
+If you want to regress task-related signals out of your data, you can use a custom confound
+configuration.
 
 Here we document how to include task effects as confounds.
 
 .. tip::
    The basic approach to task regression is to convolve your task regressors with an HRF,
-   then save those regressors to a custom confounds file.
+   then save those regressors to a confounds file.
 
 .. warning::
    This method is still under development.
@@ -471,31 +467,61 @@ plot_design_matrix.html#create-design-matrices>`_.
       index=False,
    )
 
-Then, when you run XCP-D, you can use the flag
-``--custom_confounds /my/project/directory/custom_confounds``.
+Then, create a confounds config file to include derivatives from ``custom_confounds``.
+Something like this should work:
+
+```yaml
+name: my_custom_confounds
+description: |
+   Nuisance regressors were task regressors convolved with an HRF and motion parameters.
+confounds:
+   motion:
+      dataset: preprocessed
+      query:
+         space: null
+         cohort: null
+         res: null
+         den: null
+         desc: confounds
+         extension: .tsv
+         suffix: timeseries
+      columns:
+      - trans_x
+      - trans_y
+      - trans_z
+      - rot_x
+      - rot_y
+      - rot_z
+   task:
+      dataset: custom
+      query:
+         space: null
+         cohort: null
+         res: null
+         den: null
+         desc: confounds
+         extension: .tsv
+         suffix: timeseries
+      columns:
+      - condition1
+      - condition2
+```
 
 
 Command Line XCP-D with Custom Confounds
 ========================================
 
-Last, supply the file to xcp_d with the ``--custom_confounds`` option.
-``--custom_confounds`` should point to the directory where this file exists, rather than to the
-file itself;
-XCP-D will identify the correct file based on the filename,
-which should match the name of the preprocessed BOLD data's associated confounds file.
-You can simultaneously perform additional confound regression by including,
-for example, ``--nuisance-regressors 36P`` in the call.
+Last, run XCP-D with your custom configuration file and the path to the custom derivatives dataset.
 
 .. code-block:: bash
 
-   apptainer run --cleanenv -B /my/project/directory:/mnt xcpabcd_latest.simg \
+   apptainer run --cleanenv -B /my/project/directory:/mnt xcpd_latest.sif \
       /mnt/input/fmriprep \
       /mnt/output/directory \
       participant \
       --participant_label X \
-      --task-id Z \
-      --nuisance-regressors 36P \
-      --custom_confounds /mnt/custom_confounds
+      --derivatives custom=/mnt/custom_confounds \
+      --nuisance-regressors /mnt/custom_config.yaml
 
 
 ********************
diff --git a/docs/workflows.rst b/docs/workflows.rst
index 6266865af..ad15a2cbe 100644
--- a/docs/workflows.rst
+++ b/docs/workflows.rst
@@ -302,9 +302,11 @@ Please refer to :footcite:t:`fair2020correction` and :footcite:t:`gratton2020rem
 more information.
 
 .. important::
-   Starting in version 0.4.0, if motion parameters are filtered in this step,
-   the filtered motion parameters (including FD, and any squared or derivative regressors)
-   will be used in the confound regression step.
+   Starting in version 0.4.0, if users request motion parameter filtering,
+   filtered motion parameters (including FD, and any squared or derivative regressors)
+   will be used for both outlier detection and confound regression.
+
+   Before that release, filtered motion parameters were only used for outlier detection.
 
 The two options for the motion-filtering parameter are "notch" (the band-stop filter) and
 "lp" (the low-pass filter).
@@ -368,19 +370,20 @@ Confound regressor selection
 :func:`~xcp_d.workflows.bold.postprocessing.init_prepare_confounds_wf`,
 :func:`~xcp_d.interfaces.censoring.GenerateConfounds`
 
-The confound regressor configurations in the table below are implemented in XCP-D,
-with ``36P`` as the default.
-In addition to the standard confound regressors selected from fMRIPrep outputs,
-custom confounds can be added as described in :ref:`usage_custom_confounds`.
-If you want to use custom confounds, without any of the nuisance regressors described here,
-use ``--nuisance-regressors custom``.
+XCP-D supports several different confound regressor strategies.
+In addition to the built-in regressor sets described below,
+users may design their own confound configuration files and use those instead.
+The default confound regressor set depends on the mode in which XCP-D is run-
+this corresponds to ``--nuisance-regressors auto``.
 
 If you want to skip the denoising step completely, you can use ``--nuisance-regressors none``.
 
 .. important::
-   Starting in version 0.4.0, if motion parameters were filtered earlier in the workflow,
-   the filtered motion parameters (including FD, and any squared or derivative regressors)
-   will be used in the confound regression step.
+   Starting in version 0.4.0, if users request motion parameter filtering,
+   filtered motion parameters (including FD, and any squared or derivative regressors)
+   will be used for both outlier detection and confound regression.
+
+   Before that release, filtered motion parameters were only used for outlier detection.
 
 .. list-table:: Confound
 
@@ -412,20 +415,27 @@ If you want to skip the denoising step completely, you can use ``--nuisance-regr
       - X, X\ :sup:`2`, dX, dX\ :sup:`2`
       -
       -
+   *  - acompcor
+      - X, dX
+      -
+      -
+      -
+      - 5 WM, 5 CSF
+      -
    *  - acompcor_gsr
       -  X, dX
       -
       -
       - X
-      - 10 com, 5WM, 5CSF
+      - 5 WM, 5 CSF
       -
-   *  - acompcor
+   *  - aroma
       - X, dX
+      - X
+      - X
       -
       -
-      -
-      - 10 com, 5WM, 5CSF
-      -
+      - X
    *  - aroma_gsr
       - X, dX
       - X
@@ -433,13 +443,13 @@ If you want to skip the denoising step completely, you can use ``--nuisance-regr
       - X
       -
       - X
-   *  - aroma
-      - X, dX
-      - X
-      - X
+   *  - gsr_only
+      -
       -
       -
       - X
+      -
+      -
    *  - none
       -
       -
@@ -448,7 +458,8 @@ If you want to skip the denoising step completely, you can use ``--nuisance-regr
       -
       -
 
-For more information about confound regressor selection, please refer to :footcite:t:`benchmarkp`.
+For more information about the built-in confound regressor sets,
+please refer to :footcite:t:`benchmarkp`.
 
 .. warning::
 
@@ -532,13 +543,102 @@ For more information about confound regressor selection, please refer to :footci
 
 .. important::
    fMRIPrep removed AROMA support in 23.1.0.
-   In the future, there will be an fMRIPost-AROMA BIDS App that runs AROMA on fMRIPrep outputs.
+   In order to use the ``aroma`` or ``aroma_gsr`` strategies,
+   please run ``fMRIPost-AROMA`` on your fMRIPrep outputs before running XCP-D.
+   You will need to supply the AROMA derivatives dataset to XCP-D via the ``--derivatives``
+   parameter (i.e., ``--derivatives aroma=/path/to/fmripost-aroma/dset``).
+
 
 .. warning::
    The strategy ``gsr_only`` is only appropriate for UK Biobank data,
    as those data have already been denoised with FSL FIX.
 
 
+.. _confound_config:
+
+The confound configuration file format
+--------------------------------------
+
+Users may design and employ their own custom confound configuration YAML files.
+These files are designed to allow inputs from multiple datasets,
+with flexible column and file selection.
+
+Each confound configuration file must contain a ``name``, a ``description``, and a ``confounds``
+section.
+The ``name`` and ``description`` are primarily used for documentation purposes,
+while the ``confounds`` section specifies which confounds will actually be used.
+
+The ``confounds`` section is a dictionary/object, with a unique key for each set of confounds.
+Each set of confounds must contain a ``dataset`` key, which specifies the dataset to use.
+The dataset must be linked to what the user provides in the ``--derivatives`` parameter,
+though the "preprocessed" key is a protected value for the dataset given to XCP-D as the
+``fmri_dir`` positional argument.
+For example, in the example below, three columns are collected from the fMRIPrep confounds file:
+"global_signal", "csf", and "white_matter".
+Other confounds must come from the "aroma" dataset (i.e., the output from fMRIPost-AROMA).
+Note that the "aroma" columns are selected using regular expressions, as they start with "^"
+and end with "$".
+XCP-D will collect any columns in the selected file that match the regular expression.
+
+Finally, there is the ``query`` field in each confound set.
+This defines the BIDS entities that will be used to find the confounds file associated with the
+preprocessed BOLD file that is being post-processed by XCP-D.
+
+```yaml
+name: aroma_gsr
+description: |
+   Nuisance regressors were selected according to the 'aroma_gsr' strategy.
+   AROMA motion-labeled components [@pruim2015ica], mean white matter signal,
+   mean cerebrospinal fluid signal, and mean global signal were selected as
+   nuisance regressors [@benchmarkp;@satterthwaite_2013].
+confounds:
+   preproc_confounds:
+      dataset: preprocessed
+      query:
+         space: null
+         cohort: null
+         res: null
+         den: null
+         desc: confounds
+         extension: .tsv
+         suffix: timeseries
+      columns:
+      - global_signal
+      - csf
+      - white_matter
+   aroma_confounds:
+      dataset: aroma
+      query:
+         space: null
+         cohort: null
+         res: null
+         den: null
+         desc: aroma
+         extension: .tsv
+         suffix: timeseries
+      columns:
+      - ^aroma_orth_motion_.*$
+```
+
+In addition to TSV-based confound files, XCP-D also supports the use of voxel-wise confound files.
+Take this partial example:
+
+```yaml
+confounds:
+    rapidtide_slfo:
+        dataset: rapidtide
+        query:
+            desc: LFO
+            extension: .nii.gz
+            suffix: timeseries
+```
+
+Note in this case that the confounds definition includes a query section, but not a columns section.
+This is because this query will return a 4D NIfTI file, rather than a TSV file.
+The corresponding voxel-wise confounds will be extracted from the 4D NIfTI file and regressed out
+of the BOLD data.
+
+
 Dummy scan removal [OPTIONAL]
 =============================
 :func:`~xcp_d.workflows.bold.postprocessing.init_prepare_confounds_wf`,
diff --git a/xcp_d/cli/parser.py b/xcp_d/cli/parser.py
index 7b393a29a..e1f5c3ea5 100644
--- a/xcp_d/cli/parser.py
+++ b/xcp_d/cli/parser.py
@@ -1,14 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-"""The xcp_d preprocessing worklow.
+"""The XCP-D preprocessing worklow.
 
-xcp_d preprocessing workflow
+XCP-D preprocessing workflow
 ============================
 """
 import os
 import sys
 
 from xcp_d import config
+from xcp_d.data import load as load_data
 
 
 def _build_parser():
@@ -61,7 +62,7 @@ def _build_parser():
         "analysis_level",
         action="store",
         choices=["participant"],
-        help="The analysis level for xcp_d. Must be specified as 'participant'.",
+        help="The analysis level for XCP-D. Must be specified as 'participant'.",
     )
 
     # Required "mode" argument
@@ -125,6 +126,19 @@ def _build_parser():
             "filtering-inputs-with-bids-filter-files"
         ),
     )
+    g_bids.add_argument(
+        "-d",
+        "--derivatives",
+        action=parser_utils.ToDict,
+        metavar="PACKAGE=PATH",
+        type=str,
+        nargs="+",
+        help=(
+            "Search PATH(s) for pre-computed derivatives. "
+            "These may be provided as named folders "
+            "(e.g., `--derivatives smriprep=/path/to/smriprep`)."
+        ),
+    )
     g_bids.add_argument(
         "--bids-database-dir",
         metavar="PATH",
@@ -233,7 +247,7 @@ def _build_parser():
         metavar="{{auto,INT}}",
         help=(
             "Number of volumes to remove from the beginning of each run. "
-            "If set to 'auto', xcp_d will extract non-steady-state volume indices from the "
+            "If set to 'auto', XCP-D will extract non-steady-state volume indices from the "
             "preprocessing derivatives' confounds file."
         ),
     )
@@ -257,41 +271,16 @@ def _build_parser():
         "-p",
         "--nuisance-regressors",
         "--nuisance_regressors",
-        dest="params",
+        dest="confounds_config",
         required=False,
-        choices=[
-            "27P",
-            "36P",
-            "24P",
-            "acompcor",
-            "aroma",
-            "acompcor_gsr",
-            "aroma_gsr",
-            "custom",
-            "none",
-            # GSR-only for UKB
-            "gsr_only",
-        ],
+        action=parser_utils.ConfoundsAction,
         default="auto",
-        type=str,
         help=(
             "Nuisance parameters to be selected. "
-            "Descriptions of each of the options are included in xcp_d's documentation."
-        ),
-    )
-    g_param.add_argument(
-        "-c",
-        "--custom-confounds",
-        "--custom_confounds",
-        dest="custom_confounds",
-        required=False,
-        default=None,
-        type=PathExists,
-        help=(
-            "Custom confounds to be added to the nuisance regressors. "
-            "Must be a folder containing confounds files, "
-            "in which the file with the name matching the preprocessing confounds file will be "
-            "selected."
+            "This may be a string indicating one of XCP-D's built-in nuisance regression "
+            "strategies (e.g., '36P') or a path to a YAML file formatted according to XCP-D's "
+            "confound configuration file format. "
+            "Descriptions of each of the built-in options are included in XCP-D's documentation. "
         ),
     )
     g_param.add_argument(
@@ -636,7 +625,7 @@ def _build_parser():
         default=False,
         help=(
             "Clears working directory of contents. "
-            "Use of this flag is not recommended when running concurrent processes of xcp_d."
+            "Use of this flag is not recommended when running concurrent processes of XCP-D."
         ),
     )
     g_other.add_argument(
@@ -935,10 +924,6 @@ def _validate_parameters(opts, build_log, parser):
         else:
             os.environ["FS_LICENSE"] = str(fs_license_file)
 
-    # Resolve custom confounds folder
-    if opts.custom_confounds:
-        opts.custom_confounds = str(opts.custom_confounds.resolve())
-
     # Check parameter value types/valid values
     assert opts.abcc_qc in (True, False, "auto")
     assert opts.combine_runs in (True, False, "auto")
@@ -953,6 +938,9 @@ def _validate_parameters(opts, build_log, parser):
     if opts.mode == "abcd":
         opts.abcc_qc = True if (opts.abcc_qc == "auto") else opts.abcc_qc
         opts.combine_runs = True if (opts.combine_runs == "auto") else opts.combine_runs
+        opts.confounds_config = (
+            "36P" if (opts.confounds_config == "auto") else opts.confounds_config
+        )
         opts.dcan_correlation_lengths = (
             [] if opts.dcan_correlation_lengths is None else opts.dcan_correlation_lengths
         )
@@ -967,7 +955,7 @@ def _validate_parameters(opts, build_log, parser):
         if opts.output_type == "censored":
             error_messages.append(f"'--output-type' cannot be 'censored' for '{opts.mode}' mode.")
         opts.output_type = "interpolated"
-        opts.params = "36P" if opts.params == "auto" else opts.params
+        opts.confounds_config = "36P" if opts.confounds_config == "auto" else opts.confounds_config
         opts.process_surfaces = (
             True if (opts.process_surfaces == "auto") else opts.process_surfaces
         )
@@ -976,6 +964,9 @@ def _validate_parameters(opts, build_log, parser):
     elif opts.mode == "hbcd":
         opts.abcc_qc = True if (opts.abcc_qc == "auto") else opts.abcc_qc
         opts.combine_runs = True if (opts.combine_runs == "auto") else opts.combine_runs
+        opts.confounds_config = (
+            "36P" if (opts.confounds_config == "auto") else opts.confounds_config
+        )
         opts.dcan_correlation_lengths = (
             [] if opts.dcan_correlation_lengths is None else opts.dcan_correlation_lengths
         )
@@ -990,7 +981,7 @@ def _validate_parameters(opts, build_log, parser):
         if opts.output_type == "censored":
             error_messages.append(f"'--output-type' cannot be 'censored' for '{opts.mode}' mode.")
         opts.output_type = "interpolated"
-        opts.params = "36P" if opts.params == "auto" else opts.params
+        opts.confounds_config = "36P" if opts.confounds_config == "auto" else opts.confounds_config
         opts.process_surfaces = (
             True if (opts.process_surfaces == "auto") else opts.process_surfaces
         )
@@ -999,6 +990,9 @@ def _validate_parameters(opts, build_log, parser):
     elif opts.mode == "linc":
         opts.abcc_qc = False if (opts.abcc_qc == "auto") else opts.abcc_qc
         opts.combine_runs = False if opts.combine_runs == "auto" else opts.combine_runs
+        opts.confounds_config = (
+            "36P" if (opts.confounds_config == "auto") else opts.confounds_config
+        )
         opts.despike = True if (opts.despike == "auto") else opts.despike
         opts.fd_thresh = 0 if (opts.fd_thresh == "auto") else opts.fd_thresh
         opts.file_format = "cifti" if (opts.file_format == "auto") else opts.file_format
@@ -1010,7 +1004,7 @@ def _validate_parameters(opts, build_log, parser):
                 f"'--output-type' cannot be 'interpolated' for '{opts.mode}' mode."
             )
         opts.output_type = "censored"
-        opts.params = "36P" if opts.params == "auto" else opts.params
+        opts.confounds_config = "36P" if opts.confounds_config == "auto" else opts.confounds_config
         opts.process_surfaces = False if opts.process_surfaces == "auto" else opts.process_surfaces
         if opts.dcan_correlation_lengths is not None:
             error_messages.append(f"'--create-matrices' is not supported for '{opts.mode}' mode.")
@@ -1021,6 +1015,9 @@ def _validate_parameters(opts, build_log, parser):
         if opts.combine_runs == "auto":
             error_messages.append("'--combine-runs' (y or n) is required for 'none' mode.")
 
+        if opts.confounds_config == "auto":
+            error_messages.append("'--nuisance-regressors' is required for 'none' mode.")
+
         opts.dcan_correlation_lengths = (
             [] if opts.dcan_correlation_lengths is None else opts.dcan_correlation_lengths
         )
@@ -1049,9 +1046,6 @@ def _validate_parameters(opts, build_log, parser):
         if opts.output_type == "auto":
             error_messages.append("'--output-type' is required for 'none' mode.")
 
-        if opts.params == "auto":
-            error_messages.append("'--nuisance-regressors' is required for 'none' mode.")
-
         if opts.process_surfaces == "auto":
             error_messages.append(
                 "'--warp-surfaces-native2std' (y or n) is required for 'none' mode."
@@ -1060,6 +1054,14 @@ def _validate_parameters(opts, build_log, parser):
         # Remove "all" from the list of correlation lengths
         opts.dcan_correlation_lengths = [c for c in opts.dcan_correlation_lengths if c != "all"]
 
+    # Load the confound configuration file
+    if opts.confounds_config == "none":
+        opts.confounds_config = None
+    elif isinstance(opts.confounds_config, str):  # A builtin confound config
+        opts.confounds_config = load_data.readable(f"nuisance/{opts.confounds_config}.yml")
+    else:  # An external confound config
+        opts.confounds_config = Path(opts.confounds_config).resolve()
+
     # Bandpass filter parameters
     if opts.high_pass <= 0 and opts.low_pass <= 0:
         opts.bandpass_filter = False
@@ -1162,14 +1164,6 @@ def _validate_parameters(opts, build_log, parser):
             "you must enable cifti processing (--file-format cifti)."
         )
 
-    # Warn if the user combines custom confounds with the 'none' parameter set
-    if opts.params == "none" and opts.custom_confounds:
-        build_log.warning(
-            "Custom confounds were provided, but --nuisance-regressors was set to none. "
-            "Overriding the 'none' value and setting to 'custom'."
-        )
-        opts.params = "custom"
-
     if error_messages:
         error_message_str = "Errors detected in parameter parsing:\n\t- " + "\n\t- ".join(
             error_messages
diff --git a/xcp_d/cli/parser_utils.py b/xcp_d/cli/parser_utils.py
index c84fca602..c0cf81ee1 100644
--- a/xcp_d/cli/parser_utils.py
+++ b/xcp_d/cli/parser_utils.py
@@ -142,3 +142,52 @@ def __call__(self, parser, namespace, values, option_string=None):  # noqa: U100
         lookup = {"y": True, "n": False, None: True, "auto": "auto"}
         assert values in lookup.keys(), f"Invalid value '{values}' for {self.dest}"
         setattr(namespace, self.dest, lookup[values])
+
+
+class ToDict(Action):
+    """A custom argparse "store" action to handle a list of key=value pairs."""
+
+    def __call__(self, parser, namespace, values, option_string=None):  # noqa: U100
+        """Call the argument."""
+        d = {}
+        for spec in values:
+            try:
+                name, loc = spec.split("=")
+                loc = Path(loc)
+            except ValueError:
+                loc = Path(spec)
+                name = loc.name
+
+            if name in d:
+                raise ValueError(f"Received duplicate derivative name: {name}")
+            elif name == "preprocessed":
+                raise ValueError("The 'preprocessed' derivative is reserved for internal use.")
+
+            d[name] = loc
+        setattr(namespace, self.dest, d)
+
+
+class ConfoundsAction(Action):
+    """A custom argparse "store" action to handle a path or ."""
+
+    def __call__(self, parser, namespace, values, option_string=None):  # noqa: U100
+        """Call the argument."""
+        builtins = [
+            "auto",
+            "27P",
+            "36P",
+            "24P",
+            "acompcor",
+            "aroma",
+            "acompcor_gsr",
+            "aroma_gsr",
+            "none",
+            "gsr_only",
+        ]
+        if values in builtins:
+            setattr(namespace, self.dest, values)
+        else:
+            if not Path(values).exists():
+                raise parser.error(f"Nuisance configuration does not exist: <{values}>.")
+
+            setattr(namespace, self.dest, Path(values))
diff --git a/xcp_d/cli/run.py b/xcp_d/cli/run.py
index 3b9b4f5e1..9b01df468 100644
--- a/xcp_d/cli/run.py
+++ b/xcp_d/cli/run.py
@@ -164,7 +164,6 @@ def main():
             config.execution.fmri_dir,
             config.execution.output_dir,
             atlases=config.execution.atlases,
-            custom_confounds_folder=config.execution.custom_confounds,
             dataset_links=config.execution.dataset_links,
         )
 
diff --git a/xcp_d/cli/workflow.py b/xcp_d/cli/workflow.py
index 4c058164b..a9dc335ca 100644
--- a/xcp_d/cli/workflow.py
+++ b/xcp_d/cli/workflow.py
@@ -12,8 +12,6 @@
 
 def build_workflow(config_file, retval):
     """Create the Nipype Workflow that supports the whole execution graph."""
-    from niworkflows.utils.misc import check_valid_fs_license
-
     from xcp_d import config, data
     from xcp_d.reports.core import generate_reports
     from xcp_d.utils.bids import check_pipeline_version, collect_participants
@@ -94,22 +92,13 @@ def build_workflow(config_file, retval):
         f"Run identifier: {config.execution.run_uuid}.",
     ]
 
+    if config.execution.derivatives:
+        init_msg += [f"Searching for derivatives: {config.execution.derivatives}."]
+
     build_log.log(25, f"\n{' ' * 11}* ".join(init_msg))
 
     retval["workflow"] = init_xcpd_wf()
 
-    # Check for FS license after building the workflow
-    if not check_valid_fs_license():
-        build_log.critical(
-            """\
-ERROR: a valid license file is required for FreeSurfer to run. XCP-D 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"""
-        )
-        retval["return_code"] = 126  # 126 == Command invoked cannot execute.
-        return retval
-
     # Check workflow for missing commands
     missing = check_deps(retval["workflow"])
     if missing:
diff --git a/xcp_d/config.py b/xcp_d/config.py
index d00b3d275..60666ca6e 100644
--- a/xcp_d/config.py
+++ b/xcp_d/config.py
@@ -379,6 +379,8 @@ class execution(_Config):
 
     fmri_dir = None
     """An existing path to the preprocessing derivatives dataset, which must be BIDS-compliant."""
+    derivatives = {}
+    """Path(s) to search for pre-computed derivatives"""
     aggr_ses_reports = None
     """Maximum number of sessions aggregated in one subject's visual report."""
     bids_database_dir = None
@@ -389,6 +391,8 @@ class execution(_Config):
     """A dictionary of BIDS selection filters."""
     boilerplate_only = None
     """Only generate a boilerplate."""
+    confounds_config = None
+    """Nuisance regressors to include in the postprocessing."""
     debug = []
     """Debug mode(s)."""
     fs_license_file = _fs_license
@@ -409,8 +413,6 @@ class execution(_Config):
     """Only build the reports, based on the reportlets found in a cached working directory."""
     output_dir = None
     """Folder where derivatives will be stored."""
-    custom_confounds = None
-    """A path to a folder containing custom confounds to include in the postprocessing."""
     atlases = []
     """Selection of atlases to apply to the data."""
     run_uuid = f"{strftime('%Y%m%d-%H%M%S')}_{uuid4()}"
@@ -432,6 +434,7 @@ class execution(_Config):
 
     _paths = (
         "fmri_dir",
+        "derivatives",
         "bids_database_dir",
         "fs_license_file",
         "layout",
@@ -440,6 +443,7 @@ class execution(_Config):
         "templateflow_home",
         "work_dir",
         "dataset_links",
+        "confounds_config",
     )
 
     @classmethod
@@ -491,6 +495,7 @@ def init(cls):
             cls.bids_database_dir = _db_path
 
         cls.layout = cls._layout
+
         if cls.bids_filters:
             from bids.layout import Query
 
@@ -516,9 +521,11 @@ def _process_value(value):
             cls.bids_filters["bold"]["task"] = cls.task_id
 
         dataset_links = {
-            'preprocessed': cls.fmri_dir,
-            'templateflow': Path(TF_LAYOUT.root),
+            "preprocessed": cls.fmri_dir,
+            "templateflow": Path(TF_LAYOUT.root),
         }
+        for deriv_name, deriv_path in cls.derivatives.items():
+            dataset_links[deriv_name] = deriv_path
         cls.dataset_links = dataset_links
 
         if "all" in cls.debug:
@@ -549,8 +556,6 @@ class workflow(_Config):
     """Postprocessing pipeline type."""
     despike = None
     """Despike the BOLD data before postprocessing."""
-    params = None
-    """Nuisance regressors to include in the postprocessing."""
     smoothing = None
     """Full-width at half-maximum (FWHM) of the smoothing kernel."""
     output_interpolated = None
diff --git a/xcp_d/data/nuisance/24P.yml b/xcp_d/data/nuisance/24P.yml
new file mode 100644
index 000000000..57cb31939
--- /dev/null
+++ b/xcp_d/data/nuisance/24P.yml
@@ -0,0 +1,44 @@
+name: 24P
+description: |
+    In total, 24 nuisance regressors were selected from the preprocessing confounds,
+    according to the '24P' strategy [@benchmarkp;@satterthwaite_2013].
+    These nuisance regressors included
+    six motion parameters with their temporal derivatives,
+    and their quadratic expansion of those six motion parameters and their
+    temporal derivatives.
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_x_derivative1_power2
+        - trans_x_power2
+        - trans_y
+        - trans_y_derivative1
+        - trans_y_derivative1_power2
+        - trans_y_power2
+        - trans_z
+        - trans_z_derivative1
+        - trans_z_derivative1_power2
+        - trans_z_power2
+        - rot_x
+        - rot_x_derivative1
+        - rot_x_power2
+        - rot_x_derivative1_power2
+        - rot_y
+        - rot_y_derivative1
+        - rot_y_power2
+        - rot_y_derivative1_power2
+        - rot_z
+        - rot_z_derivative1
+        - rot_z_power2
+        - rot_z_derivative1_power2
diff --git a/xcp_d/data/nuisance/27P.yml b/xcp_d/data/nuisance/27P.yml
new file mode 100644
index 000000000..81bb3a529
--- /dev/null
+++ b/xcp_d/data/nuisance/27P.yml
@@ -0,0 +1,48 @@
+name: 27P
+description: |
+    In total, 27 nuisance regressors were selected from the preprocessing confounds,
+    according to the '27P' strategy.
+    These nuisance regressors included
+    fsix {fstr}motion parameters with their temporal derivatives,
+    quadratic expansion of those six motion parameters and their derivatives,
+    mean global signal, mean white matter signal, and mean cerebrospinal fluid signal
+    [@benchmarkp;@satterthwaite_2013].
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_x_derivative1_power2
+        - trans_x_power2
+        - trans_y
+        - trans_y_derivative1
+        - trans_y_derivative1_power2
+        - trans_y_power2
+        - trans_z
+        - trans_z_derivative1
+        - trans_z_derivative1_power2
+        - trans_z_power2
+        - rot_x
+        - rot_x_derivative1
+        - rot_x_power2
+        - rot_x_derivative1_power2
+        - rot_y
+        - rot_y_derivative1
+        - rot_y_power2
+        - rot_y_derivative1_power2
+        - rot_z
+        - rot_z_derivative1
+        - rot_z_power2
+        - rot_z_derivative1_power2
+        - global_signal
+        - csf
+        - white_matter
diff --git a/xcp_d/data/nuisance/36P.yml b/xcp_d/data/nuisance/36P.yml
new file mode 100644
index 000000000..9f5bf3018
--- /dev/null
+++ b/xcp_d/data/nuisance/36P.yml
@@ -0,0 +1,57 @@
+name: 36P
+description: |
+    In total, 36 nuisance regressors were selected from the preprocessing confounds,
+    according to the '36P' strategy.
+    These nuisance regressors included
+    six motion parameters, mean global signal, mean white matter signal,
+    mean cerebrospinal fluid signal with their temporal derivatives,
+    and quadratic expansion of six motion parameters, tissue signals and
+    their temporal derivatives [@benchmarkp;@satterthwaite_2013].
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_x_derivative1_power2
+        - trans_x_power2
+        - trans_y
+        - trans_y_derivative1
+        - trans_y_derivative1_power2
+        - trans_y_power2
+        - trans_z
+        - trans_z_derivative1
+        - trans_z_derivative1_power2
+        - trans_z_power2
+        - rot_x
+        - rot_x_derivative1
+        - rot_x_power2
+        - rot_x_derivative1_power2
+        - rot_y
+        - rot_y_derivative1
+        - rot_y_power2
+        - rot_y_derivative1_power2
+        - rot_z
+        - rot_z_derivative1
+        - rot_z_power2
+        - rot_z_derivative1_power2
+        - global_signal
+        - global_signal_derivative1
+        - global_signal_power2
+        - global_signal_derivative1_power2
+        - csf
+        - csf_derivative1
+        - csf_power2
+        - csf_derivative1_power2
+        - white_matter
+        - white_matter_derivative1
+        - white_matter_power2
+        - white_matter_derivative1_power2
diff --git a/xcp_d/data/nuisance/acompcor.yml b/xcp_d/data/nuisance/acompcor.yml
new file mode 100644
index 000000000..100197302
--- /dev/null
+++ b/xcp_d/data/nuisance/acompcor.yml
@@ -0,0 +1,38 @@
+name: acompcor
+description: |
+    Nuisance regressors were selected according to the 'acompcor' strategy.
+    The top 5 aCompCor principal components from the white matter and
+    cerebrospinal fluid compartments were selected as nuisance regressors
+    [@behzadi2007component],
+    along with the six motion parameters and their temporal derivatives
+    [@benchmarkp;@satterthwaite_2013].
+    As the aCompCor regressors were generated on high-pass filtered data,
+    the associated cosine basis regressors were included.
+    This has the effect of high-pass filtering the data as well.
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_y
+        - trans_y_derivative1
+        - trans_z
+        - trans_z_derivative1
+        - rot_x
+        - rot_x_derivative1
+        - rot_y
+        - rot_y_derivative1
+        - rot_z
+        - rot_z_derivative1
+        - ^w_comp_cor_0[1-5]$
+        - ^c_comp_cor_0[1-5]$
+        - ^cosine\d+$
diff --git a/xcp_d/data/nuisance/acompcor_gsr.yml b/xcp_d/data/nuisance/acompcor_gsr.yml
new file mode 100644
index 000000000..4a11c7f5d
--- /dev/null
+++ b/xcp_d/data/nuisance/acompcor_gsr.yml
@@ -0,0 +1,42 @@
+name: acompcor_gsr
+description: |
+    Nuisance regressors were selected according to the 'acompcor_gsr' strategy.
+    The top 5 aCompCor principal components from the white matter and
+    cerebrospinal fluid compartments were selected as nuisance regressors
+    [@behzadi2007component],
+    along with the six motion parameters and their temporal derivatives,
+    mean white matter signal, mean cerebrospinal fluid signal, and mean global signal
+    [@benchmarkp;@satterthwaite_2013].
+    As the aCompCor regressors were generated on high-pass filtered data,
+    the associated cosine basis regressors were included.
+    This has the effect of high-pass filtering the data as well.
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_y
+        - trans_y_derivative1
+        - trans_z
+        - trans_z_derivative1
+        - rot_x
+        - rot_x_derivative1
+        - rot_y
+        - rot_y_derivative1
+        - rot_z
+        - rot_z_derivative1
+        - global_signal
+        - csf
+        - white_matter
+        - ^w_comp_cor_0[1-5]$
+        - ^c_comp_cor_0[1-5]$
+        - ^cosine\d+$
diff --git a/xcp_d/data/nuisance/aroma.yml b/xcp_d/data/nuisance/aroma.yml
new file mode 100644
index 000000000..e2425303d
--- /dev/null
+++ b/xcp_d/data/nuisance/aroma.yml
@@ -0,0 +1,33 @@
+name: aroma
+description: |
+    Nuisance regressors were selected according to the 'aroma' strategy.
+    AROMA motion-labeled components [@pruim2015ica], mean white matter signal,
+    and mean cerebrospinal fluid signal were selected as nuisance regressors
+    [@benchmarkp;@satterthwaite_2013].
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - csf
+        - white_matter
+    aroma_confounds:
+        dataset: aroma
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: aroma
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        # Regular expressions begin with ``^`` and end with ``$``.
+        - ^aroma_orth_motion_.*$
diff --git a/xcp_d/data/nuisance/aroma_gsr.yml b/xcp_d/data/nuisance/aroma_gsr.yml
new file mode 100644
index 000000000..801355a04
--- /dev/null
+++ b/xcp_d/data/nuisance/aroma_gsr.yml
@@ -0,0 +1,33 @@
+name: aroma_gsr
+description: |
+    Nuisance regressors were selected according to the 'aroma_gsr' strategy.
+    AROMA motion-labeled components [@pruim2015ica], mean white matter signal,
+    mean cerebrospinal fluid signal, and mean global signal were selected as
+    nuisance regressors [@benchmarkp;@satterthwaite_2013].
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - global_signal
+        - csf
+        - white_matter
+    aroma_confounds:
+        dataset: aroma
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: aroma
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - ^aroma_orth_motion_.*$
diff --git a/xcp_d/data/nuisance/gsr_only.yml b/xcp_d/data/nuisance/gsr_only.yml
new file mode 100644
index 000000000..8572a3494
--- /dev/null
+++ b/xcp_d/data/nuisance/gsr_only.yml
@@ -0,0 +1,17 @@
+name: gsr_only
+description: |
+    Nuisance regressors were selected according to the 'gsr_only' strategy.
+    Mean global signal was selected as the only nuisance regressor.
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - global_signal
diff --git a/xcp_d/data/nuisance/rapidtide+24P.yml b/xcp_d/data/nuisance/rapidtide+24P.yml
new file mode 100644
index 000000000..3d42f8b09
--- /dev/null
+++ b/xcp_d/data/nuisance/rapidtide+24P.yml
@@ -0,0 +1,53 @@
+name: 36P+rapidtide
+description: |
+    In total, 37 nuisance regressors were selected from the preprocessing confounds,
+    according to the '36P+rapidtide' strategy.
+    These nuisance regressors included
+    six motion parameters, mean global signal, mean white matter signal,
+    mean cerebrospinal fluid signal with their temporal derivatives,
+    and quadratic expansion of six motion parameters, tissue signals and
+    their temporal derivatives [@benchmarkp;@satterthwaite_2013].
+    In addition to the 36 regressors described above, the time-lagged global signal
+    from rapidtide was included as a voxel-wise nuisance regressor.
+confounds:
+    preproc_confounds:
+        dataset: preprocessed
+        query:
+            space: null
+            cohort: null
+            res: null
+            den: null
+            desc: confounds
+            extension: .tsv
+            suffix: timeseries
+        columns:
+        - trans_x
+        - trans_x_derivative1
+        - trans_x_derivative1_power2
+        - trans_x_power2
+        - trans_y
+        - trans_y_derivative1
+        - trans_y_derivative1_power2
+        - trans_y_power2
+        - trans_z
+        - trans_z_derivative1
+        - trans_z_derivative1_power2
+        - trans_z_power2
+        - rot_x
+        - rot_x_derivative1
+        - rot_x_power2
+        - rot_x_derivative1_power2
+        - rot_y
+        - rot_y_derivative1
+        - rot_y_power2
+        - rot_y_derivative1_power2
+        - rot_z
+        - rot_z_derivative1
+        - rot_z_power2
+        - rot_z_derivative1_power2
+    rapidtide_slfo:
+        dataset: rapidtide
+        query:
+            desc: LFO
+            extension: .nii.gz
+            suffix: timeseries
diff --git a/xcp_d/data/tests/config.toml b/xcp_d/data/tests/config.toml
index 25003d3d2..b0e01f04e 100644
--- a/xcp_d/data/tests/config.toml
+++ b/xcp_d/data/tests/config.toml
@@ -9,19 +9,19 @@ templateflow_version = "0.4.2"
 version = "0.6.0"
 
 [execution]
-fmri_dir = "ds000005/"
 bids_description_hash = "123456"
 bids_filters = {}
 boilerplate_only = false
 debug = []
+fmri_dir = "ds000005/"
 fs_license_file = "/opt/freesurfer/license.txt"
 log_dir = "/opt/xcp_d"
 log_level = 40
 low_mem = false
 md_only_boilerplate = false
 notrack = false
+output_dir = "ds000005/derivatives/xcp_d"
 reports_only = false
-output_dir = "ds000005/derivatives"
 run_uuid = "20240205-123456"
 templateflow_home = "~/.cache/templateflow"
 work_dir = "work/"
@@ -32,8 +32,6 @@ cifti = false
 dummy_scans = 0
 input_type = "fmriprep"
 despike = false
-params = "36P"
-custom_confounds = false
 smoothing = 6
 combine_runs = false
 motion_filter_type = false
diff --git a/xcp_d/interfaces/censoring.py b/xcp_d/interfaces/censoring.py
index 01b3e24d4..c76d84186 100644
--- a/xcp_d/interfaces/censoring.py
+++ b/xcp_d/interfaces/censoring.py
@@ -1,5 +1,6 @@
 """Interfaces for the post-processing workflows."""
 
+import json
 import os
 
 import nibabel as nb
@@ -11,18 +12,13 @@
     File,
     SimpleInterface,
     TraitedSpec,
+    isdefined,
     traits,
 )
 
-from xcp_d.utils.confounds import (
-    _infer_dummy_scans,
-    _modify_motion_filter,
-    load_confound_matrix,
-    load_motion,
-)
+from xcp_d.utils.confounds import _infer_dummy_scans, _modify_motion_filter, load_motion
 from xcp_d.utils.filemanip import fname_presuffix
 from xcp_d.utils.modified_data import _drop_dummy_scans, compute_fd
-from xcp_d.utils.write_save import write_ndata
 
 LOGGER = logging.getLogger("nipype.interface")
 
@@ -38,24 +34,25 @@ class _RemoveDummyVolumesInputSpec(BaseInterfaceInputSpec):
             "calculated in an earlier workflow from dummy_scans."
         ),
     )
-    confounds_file = traits.Either(
+    confounds_tsv = traits.Either(
         File(exists=True),
         None,
-        mandatory=True,
+        mandatory=False,
         desc=(
             "TSV file with selected confounds for denoising. "
             "May be None if denoising is disabled."
         ),
     )
-    fmriprep_confounds_file = File(
-        exists=True,
-        mandatory=True,
-        desc="fMRIPrep confounds tsv. Used for motion-based censoring.",
+    confounds_images = traits.Either(
+        traits.List(File(exists=True)),
+        None,
+        mandatory=False,
+        desc="List of images with confounds. May be None if denoising is disabled.",
     )
     motion_file = File(
         exists=True,
         mandatory=True,
-        desc="Confounds file containing only filtered motion parameters.",
+        desc="TSV file with motion regressors. Used for motion-based censoring.",
     )
     temporal_mask = File(
         exists=True,
@@ -65,23 +62,27 @@ class _RemoveDummyVolumesInputSpec(BaseInterfaceInputSpec):
 
 
 class _RemoveDummyVolumesOutputSpec(TraitedSpec):
-    confounds_file_dropped_TR = traits.Either(
-        File(exists=True),
-        None,
-        desc="TSV file with selected confounds for denoising, after removing TRs.",
-    )
-    fmriprep_confounds_file_dropped_TR = File(
-        exists=True,
-        desc="fMRIPrep confounds tsv after removing TRs. Used for motion-based censoring.",
-    )
     bold_file_dropped_TR = File(
         exists=True,
         desc="bold or cifti with volumes dropped",
     )
     dummy_scans = traits.Int(desc="Number of volumes dropped.")
+    confounds_tsv_dropped_TR = traits.Either(
+        File(exists=True),
+        None,
+        desc=(
+            "TSV file with selected confounds for denoising. "
+            "May be None if denoising is disabled."
+        ),
+    )
+    confounds_images_dropped_TR = traits.Either(
+        traits.List(File(exists=True)),
+        None,
+        desc="List of images with confounds. May be None if denoising is disabled.",
+    )
     motion_file_dropped_TR = File(
         exists=True,
-        desc="Confounds file containing only filtered motion parameters.",
+        desc="TSV file with motion parameters.",
     )
     temporal_mask_dropped_TR = File(
         exists=True,
@@ -102,7 +103,7 @@ class RemoveDummyVolumes(SimpleInterface):
     def _run_interface(self, runtime):
         dummy_scans = _infer_dummy_scans(
             dummy_scans=self.inputs.dummy_scans,
-            confounds_file=self.inputs.fmriprep_confounds_file,
+            confounds_file=self.inputs.motion_file,
         )
 
         self._results["dummy_scans"] = dummy_scans
@@ -111,12 +112,20 @@ def _run_interface(self, runtime):
         if dummy_scans == 0:
             # write the output out
             self._results["bold_file_dropped_TR"] = self.inputs.bold_file
-            self._results["fmriprep_confounds_file_dropped_TR"] = (
-                self.inputs.fmriprep_confounds_file
-            )
-            self._results["confounds_file_dropped_TR"] = self.inputs.confounds_file
+            self._results["confounds_tsv_dropped_TR"] = self.inputs.confounds_tsv
+            self._results["confounds_images_dropped_TR"] = self.inputs.confounds_images
             self._results["motion_file_dropped_TR"] = self.inputs.motion_file
             self._results["temporal_mask_dropped_TR"] = self.inputs.temporal_mask
+
+            if (
+                isdefined(self.inputs.confounds_images)
+                and self.inputs.confounds_images is not None
+            ):
+                self._results["confounds_images_dropped_TR"] = self.inputs.confounds_images
+
+            if isdefined(self.inputs.confounds_tsv) and self.inputs.confounds_tsv is not None:
+                self._results["confounds_tsv_dropped_TR"] = self.inputs.confounds_tsv
+
             return runtime
 
         # get the file names to output to
@@ -126,14 +135,8 @@ def _run_interface(self, runtime):
             suffix="_dropped",
             use_ext=True,
         )
-        self._results["fmriprep_confounds_file_dropped_TR"] = fname_presuffix(
-            self.inputs.fmriprep_confounds_file,
-            newpath=runtime.cwd,
-            suffix="_fmriprep_dropped",
-            use_ext=True,
-        )
         self._results["motion_file_dropped_TR"] = fname_presuffix(
-            self.inputs.bold_file,
+            self.inputs.motion_file,
             suffix="_motion_dropped.tsv",
             newpath=os.getcwd(),
             use_ext=False,
@@ -144,37 +147,38 @@ def _run_interface(self, runtime):
             newpath=os.getcwd(),
             use_ext=False,
         )
-
-        # Remove the dummy volumes
-        dropped_image = _drop_dummy_scans(self.inputs.bold_file, dummy_scans=dummy_scans)
-        dropped_image.to_filename(self._results["bold_file_dropped_TR"])
-
-        # Drop the first N rows from the pandas dataframe
-        fmriprep_confounds_df = pd.read_table(self.inputs.fmriprep_confounds_file)
-        fmriprep_confounds_df_dropped = fmriprep_confounds_df.drop(np.arange(dummy_scans))
-        fmriprep_confounds_df_dropped.to_csv(
-            self._results["fmriprep_confounds_file_dropped_TR"],
-            sep="\t",
-            index=False,
-        )
-
-        # Drop the first N rows from the confounds file
-        self._results["confounds_file_dropped_TR"] = None
-        if self.inputs.confounds_file:
-            self._results["confounds_file_dropped_TR"] = fname_presuffix(
+        if isdefined(self.inputs.confounds_tsv) and self.inputs.confounds_tsv is not None:
+            self._results["confounds_tsv_dropped_TR"] = fname_presuffix(
                 self.inputs.bold_file,
-                suffix="_selected_confounds_dropped.tsv",
+                suffix="_confounds_dropped.tsv",
                 newpath=os.getcwd(),
                 use_ext=False,
             )
-            confounds_df = pd.read_table(self.inputs.confounds_file)
+            confounds_df = pd.read_table(self.inputs.confounds_tsv)
             confounds_df_dropped = confounds_df.drop(np.arange(dummy_scans))
             confounds_df_dropped.to_csv(
-                self._results["confounds_file_dropped_TR"],
+                self._results["confounds_tsv_dropped_TR"],
                 sep="\t",
                 index=False,
             )
 
+        if isdefined(self.inputs.confounds_images) and self.inputs.confounds_images is not None:
+            self._results["confounds_images_dropped_TR"] = []
+            for i_file, confound_file in enumerate(self.inputs.confounds_images):
+                confound_file_dropped = fname_presuffix(
+                    confound_file,
+                    suffix=f"_conf{i_file}_dropped",
+                    newpath=os.getcwd(),
+                    use_ext=True,
+                )
+                dropped_confounds_image = _drop_dummy_scans(confound_file, dummy_scans=dummy_scans)
+                dropped_confounds_image.to_filename(confound_file_dropped)
+                self._results["confounds_images_dropped_TR"].append(confound_file_dropped)
+
+        # Remove the dummy volumes
+        dropped_image = _drop_dummy_scans(self.inputs.bold_file, dummy_scans=dummy_scans)
+        dropped_image.to_filename(self._results["bold_file_dropped_TR"])
+
         # Drop the first N rows from the motion file
         motion_df = pd.read_table(self.inputs.motion_file)
         motion_df_dropped = motion_df.drop(np.arange(dummy_scans))
@@ -210,17 +214,28 @@ class _CensorInputSpec(BaseInterfaceInputSpec):
             "This is a TSV file with one column: 'framewise_displacement'."
         ),
     )
+    column = traits.Str(
+        default="framewise_displacement",
+        usedefault=True,
+        mandatory=False,
+        desc="Column name in the temporal mask to use for censoring.",
+    )
 
 
 class _CensorOutputSpec(TraitedSpec):
-    censored_denoised_bold = File(
+    out_file = File(
         exists=True,
         desc="Censored BOLD file",
     )
 
 
 class Censor(SimpleInterface):
-    """Apply temporal mask to data."""
+    """Apply temporal mask to data.
+
+    If a column other than "framewise_displacement" is used, then this assumes that the outliers
+    flagged by "framewise_displacement" have already been removed from the BOLD file, and it
+    reduces the data further.
+    """
 
     input_spec = _CensorInputSpec
     output_spec = _CensorOutputSpec
@@ -228,54 +243,78 @@ class Censor(SimpleInterface):
     def _run_interface(self, runtime):
         # Read in temporal mask
         censoring_df = pd.read_table(self.inputs.temporal_mask)
-        motion_outliers = censoring_df["framewise_displacement"].to_numpy()
+        img = nb.load(self.inputs.in_file)
 
-        if np.sum(motion_outliers) == 0:  # No censoring needed
-            self._results["censored_denoised_bold"] = self.inputs.in_file
+        if self.inputs.column not in censoring_df.columns:
+            raise ValueError(
+                f"Column '{self.inputs.column}' not found in temporal mask file "
+                f"({self.inputs.temporal_mask})."
+            )
+
+        # Drop the high-motion volumes, because the image is already censored
+        if self.inputs.column != "framewise_displacement":
+            censoring_df = censoring_df.loc[censoring_df["framewise_displacement"] == 0]
+            censoring_df.reset_index(drop=True, inplace=True)
+
+        retain_idx = censoring_df.loc[censoring_df[self.inputs.column] == 0].index.values
+        motion_outliers = censoring_df.loc[censoring_df[self.inputs.column] != 0].index.values
+
+        if motion_outliers.size == 0:  # No censoring needed
+            self._results["out_file"] = self.inputs.in_file
             return runtime
 
         # Read in other files
-        bold_img_interp = nb.load(self.inputs.in_file)
-        bold_data_interp = bold_img_interp.get_fdata()
+        img = nb.load(self.inputs.in_file)
+        data = img.get_fdata()
 
-        is_nifti = bold_img_interp.ndim > 2
+        is_nifti = img.ndim > 2
         if is_nifti:
-            bold_data_censored = bold_data_interp[:, :, :, motion_outliers == 0]
+            if censoring_df.shape[0] != img.shape[3]:
+                raise ValueError(
+                    f"Number of volumes in the temporal mask ({censoring_df.shape[0]}) "
+                    f"does not match the NIfTI ({img.shape[3]})."
+                )
+
+            data_censored = data[:, :, :, retain_idx]
 
-            bold_img_censored = nb.Nifti1Image(
-                bold_data_censored,
-                affine=bold_img_interp.affine,
-                header=bold_img_interp.header,
+            img_censored = nb.Nifti1Image(
+                data_censored,
+                affine=img.affine,
+                header=img.header,
             )
         else:
-            bold_data_censored = bold_data_interp[motion_outliers == 0, :]
+            if censoring_df.shape[0] != img.shape[0]:
+                raise ValueError(
+                    f"Number of volumes in the temporal mask ({censoring_df.shape[0]}) "
+                    f"does not match the CIFTI ({img.shape[0]})."
+                )
 
-            time_axis, brain_model_axis = [
-                bold_img_interp.header.get_axis(i) for i in range(bold_img_interp.ndim)
-            ]
-            new_total_volumes = bold_data_censored.shape[0]
+            data_censored = data[retain_idx, :]
+
+            time_axis, brain_model_axis = [img.header.get_axis(i) for i in range(img.ndim)]
+            new_total_volumes = data_censored.shape[0]
             censored_time_axis = time_axis[:new_total_volumes]
-            # Note: not an error. A time axis cannot be accessed with irregularly
-            # spaced values. Since we use the temporal_mask for marking the volumes removed,
+            # Note: not an error. A time axis cannot be accessed with irregularly spaced values.
+            # Since we use the temporal_mask for marking the volumes removed,
             # the time axis also is not used further in XCP-D.
             censored_header = nb.cifti2.Cifti2Header.from_axes(
                 (censored_time_axis, brain_model_axis)
             )
-            bold_img_censored = nb.Cifti2Image(
-                bold_data_censored,
+            img_censored = nb.Cifti2Image(
+                data_censored,
                 header=censored_header,
-                nifti_header=bold_img_interp.nifti_header,
+                nifti_header=img.nifti_header,
             )
 
         # get the output
-        self._results["censored_denoised_bold"] = fname_presuffix(
+        self._results["out_file"] = fname_presuffix(
             self.inputs.in_file,
             suffix="_censored",
             newpath=runtime.cwd,
             use_ext=True,
         )
 
-        bold_img_censored.to_filename(self._results["censored_denoised_bold"])
+        img_censored.to_filename(self._results["out_file"])
         return runtime
 
 
@@ -362,13 +401,7 @@ def _run_interface(self, runtime):
         return runtime
 
 
-class _GenerateConfoundsInputSpec(BaseInterfaceInputSpec):
-    in_file = File(
-        exists=True,
-        mandatory=True,
-        desc="BOLD file after denoising, interpolation, and filtering",
-    )
-    params = traits.Str(mandatory=True, desc="Parameter set for regression.")
+class _ProcessMotionInputSpec(BaseInterfaceInputSpec):
     TR = traits.Float(mandatory=True, desc="Repetition time in seconds")
     fd_thresh = traits.Float(
         mandatory=False,
@@ -376,22 +409,16 @@ class _GenerateConfoundsInputSpec(BaseInterfaceInputSpec):
         desc="Framewise displacement threshold. All values above this will be dropped.",
     )
     head_radius = traits.Float(mandatory=False, default_value=50, desc="Head radius in mm ")
-    fmriprep_confounds_file = File(
+    motion_file = File(
         exists=True,
         mandatory=True,
         desc="fMRIPrep confounds tsv.",
     )
-    fmriprep_confounds_json = File(
+    motion_json = File(
         exists=True,
         mandatory=True,
         desc="fMRIPrep confounds json.",
     )
-    custom_confounds_file = traits.Either(
-        None,
-        File(exists=True),
-        mandatory=True,
-        desc="Custom confounds tsv.",
-    )
     motion_filter_type = traits.Either(
         None,
         traits.Str,
@@ -416,25 +443,12 @@ class _GenerateConfoundsInputSpec(BaseInterfaceInputSpec):
     )
 
 
-class _GenerateConfoundsOutputSpec(TraitedSpec):
-    filtered_confounds_file = File(
-        exists=True,
-        desc=(
-            "The original fMRIPrep confounds, with the motion parameters and their Volterra "
-            "expansion regressors replaced with filtered versions."
-        ),
-    )
-    confounds_file = traits.Either(
-        File(exists=True),
-        None,
-        desc="The selected confounds. This may include custom confounds as well.",
-    )
-    confounds_metadata = traits.Dict(desc="Metadata associated with the confounds_file output.")
+class _ProcessMotionOutputSpec(TraitedSpec):
     motion_file = File(
         exists=True,
         desc="The filtered motion parameters.",
     )
-    motion_metadata = traits.Dict(desc="Metadata associated with the filtered_motion output.")
+    motion_metadata = traits.Dict(desc="Metadata associated with the motion_file output.")
     temporal_mask = File(
         exists=True,
         desc=(
@@ -447,17 +461,16 @@ class _GenerateConfoundsOutputSpec(TraitedSpec):
     )
 
 
-class GenerateConfounds(SimpleInterface):
-    """Load, consolidate, and filter confounds.
+class ProcessMotion(SimpleInterface):
+    """Load and filter motion regressors in order to generate a temporal mask."""
 
-    Also, generate the temporal mask.
-    """
-
-    input_spec = _GenerateConfoundsInputSpec
-    output_spec = _GenerateConfoundsOutputSpec
+    input_spec = _ProcessMotionInputSpec
+    output_spec = _ProcessMotionOutputSpec
 
     def _run_interface(self, runtime):
-        fmriprep_confounds_df = pd.read_table(self.inputs.fmriprep_confounds_file)
+        with open(self.inputs.motion_json, "r") as f:
+            motion_metadata = json.load(f)
+
         band_stop_min_adjusted, band_stop_max_adjusted, _ = _modify_motion_filter(
             motion_filter_type=self.inputs.motion_filter_type,
             band_stop_min=self.inputs.band_stop_min,
@@ -466,7 +479,7 @@ def _run_interface(self, runtime):
         )
 
         motion_df = load_motion(
-            fmriprep_confounds_df.copy(),
+            self.inputs.motion_file,
             TR=self.inputs.TR,
             motion_filter_type=self.inputs.motion_filter_type,
             motion_filter_order=self.inputs.motion_filter_order,
@@ -475,60 +488,36 @@ def _run_interface(self, runtime):
         )
 
         # Add in framewise displacement
-        fd_timeseries = compute_fd(
+        motion_df["framewise_displacement"] = compute_fd(
             confound=motion_df,
             head_radius=self.inputs.head_radius,
+            filtered=False,
         )
-        motion_df["framewise_displacement"] = fd_timeseries
-
-        # A file to house the modified fMRIPrep confounds.
-        self._results["filtered_confounds_file"] = fname_presuffix(
-            self.inputs.fmriprep_confounds_file,
-            suffix="_filtered",
-            newpath=runtime.cwd,
-            use_ext=True,
-        )
-
-        # Replace original motion parameters with filtered versions
-        for col in motion_df.columns.tolist():
-            # Check that the column already exists, in case fMRIPrep changes column names.
-            # We don't want to use the original motion parameters accidentally.
-            if col not in fmriprep_confounds_df.columns:
-                raise ValueError(
-                    f"Column '{col}' not found in confounds "
-                    f"{self.inputs.fmriprep_confounds_file}. "
-                    "Please open an issue on GitHub."
-                )
-
-            fmriprep_confounds_df[col] = motion_df[col]
-
-        fmriprep_confounds_df.to_csv(
-            self._results["filtered_confounds_file"],
-            sep="\t",
-            index=False,
-        )
-
-        # Load nuisance regressors, but use filtered motion parameters.
-        confounds_df, confounds_metadata = load_confound_matrix(
-            params=self.inputs.params,
-            img_file=self.inputs.in_file,
-            confounds_file=self._results["filtered_confounds_file"],
-            confounds_json_file=self.inputs.fmriprep_confounds_json,
-            custom_confounds=self.inputs.custom_confounds_file,
-        )
+        fd_timeseries = motion_df["framewise_displacement"].to_numpy()
+        if self.inputs.motion_filter_type:
+            motion_df["framewise_displacement_filtered"] = compute_fd(
+                confound=motion_df,
+                head_radius=self.inputs.head_radius,
+                filtered=True,
+            )
+            fd_timeseries = motion_df["framewise_displacement_filtered"].to_numpy()
 
         # Compile motion metadata from confounds metadata, adding in filtering info
-        motion_metadata = {}
+        # First drop any columns that are not motion parameters
+        orig_motion_df = pd.read_table(self.inputs.motion_file)
+        orig_motion_cols = orig_motion_df.columns.tolist()
+        cols_to_drop = sorted(list(set(orig_motion_cols) - set(motion_df.columns.tolist())))
+        motion_metadata = {k: v for k, v in motion_metadata.items() if k not in cols_to_drop}
         for col in motion_df.columns.tolist():
-            col_metadata = confounds_metadata.get(col, {})
-            if col == "framewise_displacement":
+            col_metadata = motion_metadata.get(col, {})
+            if col.startswith("framewise_displacement"):
                 col_metadata["Description"] = (
                     "Framewise displacement calculated according to Power et al. (2012)."
                 )
                 col_metadata["Units"] = "mm"
                 col_metadata["HeadRadius"] = self.inputs.head_radius
 
-            if self.inputs.motion_filter_type == "lp":
+            if self.inputs.motion_filter_type == "lp" and col.endswith("_filtered"):
                 filters = col_metadata.get("SoftwareFilters", {})
                 filters["Butterworth low-pass filter"] = {
                     "cutoff": band_stop_min_adjusted / 60,
@@ -538,7 +527,7 @@ def _run_interface(self, runtime):
                 }
                 col_metadata["SoftwareFilters"] = filters
 
-            elif self.inputs.motion_filter_type == "notch":
+            elif self.inputs.motion_filter_type == "notch" and col.endswith("_filtered"):
                 filters = col_metadata.get("SoftwareFilters", {})
                 filters["IIR notch digital filter"] = {
                     "cutoff": [
@@ -555,78 +544,15 @@ def _run_interface(self, runtime):
 
         self._results["motion_metadata"] = motion_metadata
 
-        if confounds_df is not None:
-            # Update confounds metadata with modified motion metadata
-            for col in motion_df.columns.tolist():
-                if col in confounds_df.columns:
-                    base_metadata = confounds_metadata.get(col, {})
-                    base_metadata.update(motion_metadata[col])
-                    confounds_metadata[col] = base_metadata
-
-            # Orthogonalize full nuisance regressors w.r.t. any signal regressors
-            signal_columns = [c for c in confounds_df.columns if c.startswith("signal__")]
-            if signal_columns:
-                LOGGER.warning(
-                    "Signal columns detected. "
-                    "Orthogonalizing nuisance columns w.r.t. the following signal columns: "
-                    f"{', '.join(signal_columns)}"
-                )
-                noise_columns = [c for c in confounds_df.columns if not c.startswith("signal__")]
-
-                orth_cols = [f"{c}_orth" for c in noise_columns]
-                orth_confounds_df = pd.DataFrame(
-                    index=confounds_df.index,
-                    columns=orth_cols,
-                )
-
-                # Do the orthogonalization
-                signal_regressors = confounds_df[signal_columns].to_numpy()
-                noise_regressors = confounds_df[noise_columns].to_numpy()
-                signal_betas = np.linalg.lstsq(signal_regressors, noise_regressors, rcond=None)[0]
-                pred_noise_regressors = np.dot(signal_regressors, signal_betas)
-                orth_noise_regressors = noise_regressors - pred_noise_regressors
-
-                # Replace the old data
-                orth_confounds_df.loc[:, orth_cols] = orth_noise_regressors
-                confounds_df = orth_confounds_df
-
-                for col in noise_columns:
-                    desc_str = (
-                        "This regressor is orthogonalized with respect to the 'signal' regressors "
-                        f"({', '.join(signal_columns)}) after dummy scan removal, "
-                        "but prior to any censoring."
-                    )
-
-                    col_metadata = {}
-                    if col in confounds_metadata.keys():
-                        col_metadata = confounds_metadata.pop(col)
-                        if "Description" in col_metadata.keys():
-                            desc_str = f"{col_metadata['Description']} {desc_str}"
-
-                    col_metadata["Description"] = desc_str
-                    confounds_metadata[f"{col}_orth"] = col_metadata
-
-        self._results["confounds_metadata"] = confounds_metadata
-
-        # get the output
+        # Store the filtered motion parameters
         self._results["motion_file"] = fname_presuffix(
-            self.inputs.fmriprep_confounds_file,
+            self.inputs.motion_file,
             suffix="_motion",
             newpath=runtime.cwd,
             use_ext=True,
         )
         motion_df.to_csv(self._results["motion_file"], sep="\t", index=False)
 
-        self._results["confounds_file"] = None
-        if confounds_df is not None:
-            self._results["confounds_file"] = fname_presuffix(
-                self.inputs.fmriprep_confounds_file,
-                suffix="_confounds",
-                newpath=runtime.cwd,
-                use_ext=True,
-            )
-            confounds_df.to_csv(self._results["confounds_file"], sep="\t", index=False)
-
         # Generate temporal mask with all timepoints have FD over threshold set to 1.
         outlier_mask = np.zeros(len(fd_timeseries), dtype=int)
         if self.inputs.fd_thresh > 0:
@@ -663,70 +589,378 @@ def _run_interface(self, runtime):
         return runtime
 
 
-class _ReduceCiftiInputSpec(BaseInterfaceInputSpec):
+class _GenerateConfoundsInputSpec(BaseInterfaceInputSpec):
     in_file = File(
         exists=True,
         mandatory=True,
-        desc="CIFTI timeseries file to reduce.",
+        desc="Preprocessed BOLD file",
     )
-    temporal_mask = File(
-        exists=True,
+    TR = traits.Float(mandatory=True, desc="Repetition time in seconds")
+    confounds_files = traits.Dict(
         mandatory=True,
         desc=(
-            "Temporal mask; all motion outlier volumes set to 1. "
-            "This is a TSV file with one column: 'framewise_displacement'."
+            "Dictionary of confound names and paths to corresponding files. "
+            "Keys are confound names, values are dictionaries with keys 'file' and 'metadata'."
         ),
     )
-    column = traits.Str(
+    confounds_config = traits.Dict(
         mandatory=True,
-        desc="Column name in the temporal mask to use for censoring.",
+        desc="Configuration file for confounds.",
+    )
+    dataset_links = traits.Dict(
+        mandatory=True,
+        desc="Dataset links for the XCP-D run.",
+    )
+    out_dir = traits.Str(
+        mandatory=True,
+        desc=(
+            "Output directory for the XCP-D run. "
+            "Not used to write out any files- just used for dataset links."
+        ),
+    )
+    motion_filter_type = traits.Either(
+        None,
+        traits.Str,
+        mandatory=True,
+    )
+    motion_filter_order = traits.Either(
+        None,
+        traits.Int,
+        mandatory=True,
+    )
+    band_stop_min = traits.Either(
+        None,
+        traits.Float,
+        mandatory=True,
+        desc="Lower frequency for the band-stop motion filter, in breaths-per-minute (bpm).",
+    )
+    band_stop_max = traits.Either(
+        None,
+        traits.Float,
+        mandatory=True,
+        desc="Upper frequency for the band-stop motion filter, in breaths-per-minute (bpm).",
     )
 
 
-class _ReduceCiftiOutputSpec(TraitedSpec):
-    out_file = File(
+class _GenerateConfoundsOutputSpec(TraitedSpec):
+    confounds_tsv = File(
         exists=True,
-        desc="Censored CIFTI file.",
+        desc="The aggregated confounds in a tabular file.",
+    )
+    confounds_images = traits.List(
+        File(exists=True),
+        desc="The aggregated confounds in image files.",
     )
+    confounds_metadata = traits.Dict(desc="Metadata associated with the confounds output.")
 
 
-class ReduceCifti(SimpleInterface):
-    """Remove flagged volumes from a CIFTI series file."""
+class GenerateConfounds(SimpleInterface):
+    """Load confounds according to a configuration file.
+
+    This function basically checks that each confounds file has the right number of volumes,
+    selects the requisite columns from each input tabular file, and puts those columns into a
+    single tabular file.
+
+    It also applies the motion filter to motion-based regressors, if any are detected.
+    NOTE: This interface identifies motion-based regressors based on their names.
+    If the names of the motion-based regressors are not as expected,
+    the motion filter will not be applied.
+
+    Parameters
+    ----------
+    confounds_files : dict
+        Dictionary of confound names and paths to corresponding files.
+        Keys are confound names, values are dictionaries with keys "file" and "metadata".
+    confounds_config : dict
+        Configuration file for confounds.
+    n_volumes : int
+        Number of volumes in the fMRI data.
+
+    Returns
+    -------
+    confounds_tsv : str or None
+        Path to the TSV file containing combined tabular confounds.
+        None if no tabular confounds are present.
+    confounds_images : list of str
+        List of paths to the voxelwise confounds images.
+    """
 
-    input_spec = _ReduceCiftiInputSpec
-    output_spec = _ReduceCiftiOutputSpec
+    input_spec = _GenerateConfoundsInputSpec
+    output_spec = _GenerateConfoundsOutputSpec
 
     def _run_interface(self, runtime):
-        # Read in temporal mask
-        censoring_df = pd.read_table(self.inputs.temporal_mask)
-        img = nb.load(self.inputs.in_file)
+        import re
+
+        import nibabel as nb
+        import pandas as pd
+
+        from xcp_d.utils.bids import make_bids_uri
+        from xcp_d.utils.confounds import filter_motion, volterra
+
+        in_img = nb.load(self.inputs.in_file)
+        if in_img.ndim == 2:  # CIFTI
+            n_volumes = in_img.shape[0]
+        else:  # NIfTI
+            n_volumes = in_img.shape[3]
+
+        new_confound_df = pd.DataFrame(index=np.arange(n_volumes))
+
+        confounds_images = []
+        confounds_metadata = {}
+        confound_files = []
+        confounds_image_names = []
+        for confound_name, confound_info in self.inputs.confounds_files.items():
+            confound_file = confound_info["file"]
+            confound_files.append(confound_file)
+            confound_metadata = confound_info["metadata"]
+            confound_params = self.inputs.confounds_config["confounds"][confound_name]
+            if "columns" in confound_params:  # Tabular confounds
+                confound_df = pd.read_table(confound_file)
+                if confound_df.shape[0] != n_volumes:
+                    raise ValueError(
+                        f"Number of volumes in confounds file ({confound_df.shape[0]}) "
+                        f"does not match number of volumes in the fMRI data ({n_volumes})."
+                    )
 
-        if self.inputs.column not in censoring_df.columns:
-            raise ValueError(
-                f"Column '{self.inputs.column}' not found in temporal mask file "
-                f"({self.inputs.temporal_mask})."
+                available_columns = confound_df.columns.tolist()
+                required_columns = confound_params["columns"]
+                for column in required_columns:
+                    if column.startswith("^"):
+                        # Regular expression
+                        found_columns = [
+                            col_name
+                            for col_name in available_columns
+                            if re.match(column, col_name, re.IGNORECASE)
+                        ]
+                        if not found_columns:
+                            raise ValueError(
+                                f"No columns found matching regular expression '{column}'"
+                            )
+
+                        for found_column in found_columns:
+                            if found_column in new_confound_df:
+                                raise ValueError(
+                                    f"Duplicate column name ({found_column}) in confounds "
+                                    "configuration."
+                                )
+
+                            new_confound_df[found_column] = confound_df[found_column]
+
+                            # Replace NaNs in new column with zeros
+                            new_confound_df.fillna({found_column: 0}, inplace=True)
+
+                            confounds_metadata[found_column] = confounds_metadata.get(
+                                found_column, {}
+                            )
+                            confounds_metadata[found_column]["Sources"] = make_bids_uri(
+                                in_files=[confound_file],
+                                dataset_links=self.inputs.dataset_links,
+                                out_dir=self.inputs.out_dir,
+                            )
+                    else:
+                        if column not in confound_df.columns:
+                            raise ValueError(f"Column '{column}' not found in confounds file.")
+
+                        if column in new_confound_df:
+                            raise ValueError(
+                                f"Duplicate column name ({column}) in confounds configuration."
+                            )
+
+                        new_confound_df[column] = confound_df[column]
+
+                        # Replace NaNs in new column with zeros
+                        new_confound_df.fillna({column: 0}, inplace=True)
+
+                        confounds_metadata[column] = confounds_metadata.get(column, {})
+                        confounds_metadata[column]["Sources"] = make_bids_uri(
+                            in_files=[confound_file],
+                            dataset_links=self.inputs.dataset_links,
+                            out_dir=self.inputs.out_dir,
+                        )
+
+                # Collect column metadata
+                for column in new_confound_df.columns:
+                    if column in confound_metadata:
+                        confounds_metadata[column] = confound_metadata[column]
+                    else:
+                        confounds_metadata[column] = {}
+
+            else:  # Voxelwise confounds
+                confound_img = nb.load(confound_file)
+                if confound_img.ndim == 2:  # CIFTI
+                    n_volumes_check = confound_img.shape[0]
+                else:  # NIfTI
+                    n_volumes_check = confound_img.shape[3]
+
+                if n_volumes_check != n_volumes:
+                    raise ValueError(
+                        f"Number of volumes in confounds image ({n_volumes_check}) "
+                        f"does not match number of volumes in the fMRI data ({n_volumes})."
+                    )
+
+                confounds_images.append(confound_file)
+                confounds_image_names.append(confound_name)
+
+                # Collect image metadata
+                new_confound_df.loc[:, confound_name] = np.nan  # fill with NaNs as a placeholder
+                confounds_metadata[confound_name] = confound_metadata
+                confounds_metadata[confound_name]["Sources"] = make_bids_uri(
+                    in_files=[confound_file],
+                    dataset_links=self.inputs.dataset_links,
+                    out_dir=self.inputs.out_dir,
+                )
+                confounds_metadata[confound_name]["Description"] = (
+                    "A placeholder column representing a voxel-wise confound. "
+                    "The actual confound data are stored in an imaging file."
+                )
+
+        # This actually gets overwritten in init_postproc_derivatives_wf.
+        confounds_metadata["Sources"] = make_bids_uri(
+            in_files=confound_files,
+            dataset_links=self.inputs.dataset_links,
+            out_dir=self.inputs.out_dir,
+        )
+
+        if self.inputs.motion_filter_type:
+            # Filter the motion parameters
+            # 1. Pop out the 6 basic motion parameters
+            # 2. Filter them
+            # 3. Calculate the Volterra expansion of the filtered parameters
+            # 4. For each selected motion confound, remove that column and replace with the
+            #    filtered version. Include `_filtered` in the new column name.
+            motion_params = ["trans_x", "trans_y", "trans_z", "rot_x", "rot_y", "rot_z"]
+            motion_based_params = [
+                c for c in new_confound_df.columns if any(c.startswith(p) for p in motion_params)
+            ]
+            # Motion-based regressors detected
+            if len(motion_based_params):
+                # Check the motion filter parameters
+                band_stop_min_adjusted, band_stop_max_adjusted, _ = _modify_motion_filter(
+                    motion_filter_type=self.inputs.motion_filter_type,
+                    band_stop_min=self.inputs.band_stop_min,
+                    band_stop_max=self.inputs.band_stop_max,
+                    TR=self.inputs.TR,
+                )
+
+                # Filter the base motion parameters and calculate the Volterra expansion
+                base_motion_columns = [c for c in new_confound_df.columns if c in motion_params]
+                motion_df = new_confound_df[base_motion_columns]
+                motion_df.loc[:, :] = filter_motion(
+                    data=motion_df.to_numpy(),
+                    TR=self.inputs.TR,
+                    motion_filter_type=self.inputs.motion_filter_type,
+                    band_stop_min=band_stop_min_adjusted,
+                    band_stop_max=band_stop_max_adjusted,
+                    motion_filter_order=self.inputs.motion_filter_order,
+                )
+                motion_df = volterra(motion_df)
+                motion_df.fillna(0, inplace=True)
+
+                # Patch in the filtered motion parameters to the confounds DataFrame
+                overlapping_columns = [
+                    c for c in new_confound_df.columns if c in motion_df.columns
+                ]
+                motion_unfiltered = [
+                    c for c in motion_based_params if c not in overlapping_columns
+                ]
+                if motion_unfiltered:
+                    raise ValueError(
+                        f"Motion-based regressors {motion_unfiltered} were not filtered."
+                    )
+
+                # Select the relevant filtered motion parameter columns
+                motion_df = motion_df[overlapping_columns]
+                motion_df.columns = [f"{c}_filtered" for c in motion_df.columns]
+
+                # Replace the original motion columns with the filtered versions
+                new_confound_df.drop(columns=overlapping_columns, inplace=True)
+                new_confound_df = pd.concat([new_confound_df, motion_df], axis=1)
+
+                # Replace the original motion metadata with the filtered versions
+                for column in overlapping_columns:
+                    col_metadata = confounds_metadata[column]
+
+                    if self.inputs.motion_filter_type == "lp":
+                        filters = col_metadata.get("SoftwareFilters", {})
+                        filters["Butterworth low-pass filter"] = {
+                            "cutoff": band_stop_min_adjusted / 60,
+                            "order": self.inputs.motion_filter_order,
+                            "cutoff units": "Hz",
+                            "function": "scipy.signal.filtfilt",
+                        }
+                        col_metadata["SoftwareFilters"] = filters
+
+                    elif self.inputs.motion_filter_type == "notch":
+                        filters = col_metadata.get("SoftwareFilters", {})
+                        filters["IIR notch digital filter"] = {
+                            "cutoff": [
+                                band_stop_max_adjusted / 60,
+                                band_stop_min_adjusted / 60,
+                            ],
+                            "order": self.inputs.motion_filter_order,
+                            "cutoff units": "Hz",
+                            "function": "scipy.signal.filtfilt",
+                        }
+                        col_metadata["SoftwareFilters"] = filters
+
+                    confounds_metadata[f"{column}_filtered"] = col_metadata
+                    confounds_metadata.pop(column, None)
+
+        # Orthogonalize nuisance regressors w.r.t. any signal regressors
+        signal_regressors = [c for c in new_confound_df.columns if c.startswith("signal__")]
+        if signal_regressors:
+            LOGGER.warning(
+                "Signal regressors detected. "
+                "Orthogonalizing nuisance regressors w.r.t. the following signal regressors: "
+                f"{', '.join(signal_regressors)}"
             )
+            noise_regressors = [c for c in new_confound_df.columns if not c.startswith("signal__")]
 
-        # Drop the high-motion volumes, because the CIFTI is already censored
-        if self.inputs.column != "framewise_displacement":
-            censoring_df = censoring_df.loc[censoring_df["framewise_displacement"] == 0]
-            censoring_df.reset_index(drop=True, inplace=True)
-            if censoring_df.shape[0] != img.shape[0]:
-                raise ValueError(
-                    f"Number of volumes in the temporal mask ({censoring_df.shape[0]}) "
-                    f"does not match the CIFTI ({img.shape[0]})."
+            orth_cols = [f"{c}_orth" for c in noise_regressors]
+            orth_confounds_df = pd.DataFrame(
+                index=new_confound_df.index,
+                columns=orth_cols,
+            )
+            if confounds_image_names:
+                raise NotImplementedError(
+                    "Orthogonalization of confounds with respect to signal regressors is not yet "
+                    "supported for voxelwise confounds."
                 )
+            else:
+                # Do the orthogonalization
+                signal_arr = new_confound_df[signal_regressors].to_numpy()
+                noise_arr = new_confound_df[noise_regressors].to_numpy()
+                signal_betas = np.linalg.lstsq(signal_arr, noise_arr, rcond=None)[0]
+                pred_noise_regressors = np.dot(signal_arr, signal_betas)
+                orth_noise_regressors = noise_arr - pred_noise_regressors
 
-        data = img.get_fdata()
-        retain_idx = (censoring_df[self.inputs.column] == 0).index.values
-        data = data[retain_idx, ...]
+                # Replace the old data
+                orth_confounds_df.loc[:, orth_cols] = orth_noise_regressors
+                new_confound_df = orth_confounds_df
 
-        self._results["out_file"] = fname_presuffix(
-            self.inputs.in_file,
-            prefix=f"{self.inputs.column}_",
+            for col in noise_regressors:
+                desc_str = (
+                    "This regressor is orthogonalized with respect to the 'signal' regressors "
+                    f"({', '.join(signal_regressors)}) after dummy scan removal, "
+                    "but prior to any censoring."
+                )
+
+                col_metadata = {}
+                if col in confounds_metadata.keys():
+                    col_metadata = confounds_metadata.pop(col)
+                    if "Description" in col_metadata.keys():
+                        desc_str = f"{col_metadata['Description']} {desc_str}"
+
+                col_metadata["Description"] = desc_str
+                confounds_metadata[f"{col}_orth"] = col_metadata
+
+        self._results["confounds_tsv"] = fname_presuffix(
+            "desc-confounds_timeseries.tsv",
             newpath=runtime.cwd,
             use_ext=True,
         )
-        write_ndata(data.T, template=self.inputs.in_file, filename=self._results["out_file"])
+        new_confound_df.to_csv(self._results["confounds_tsv"], sep="\t", index=False)
 
+        self._results["confounds_images"] = confounds_images
+        self._results["confounds_metadata"] = confounds_metadata
         return runtime
diff --git a/xcp_d/interfaces/concatenation.py b/xcp_d/interfaces/concatenation.py
index 7daed960c..e563bbb82 100644
--- a/xcp_d/interfaces/concatenation.py
+++ b/xcp_d/interfaces/concatenation.py
@@ -62,7 +62,7 @@ class _FilterOutFailedRunsInputSpec(BaseInterfaceInputSpec):
         mandatory=True,
         desc="Preprocessed BOLD files, after dummy volume removal.",
     )
-    fmriprep_confounds_file = traits.List(
+    motion_file = traits.List(
         traits.Either(
             File(exists=True),
             Undefined,
@@ -70,14 +70,6 @@ class _FilterOutFailedRunsInputSpec(BaseInterfaceInputSpec):
         mandatory=True,
         desc="TSV files with fMRIPrep confounds for individual BOLD runs.",
     )
-    filtered_motion = traits.List(
-        traits.Either(
-            File(exists=True),
-            Undefined,
-        ),
-        mandatory=True,
-        desc="TSV files with filtered motion parameters, used for FD calculation.",
-    )
     temporal_mask = traits.List(
         traits.Either(
             File(exists=True),
@@ -145,14 +137,10 @@ class _FilterOutFailedRunsOutputSpec(TraitedSpec):
         File(exists=True),
         desc="Preprocessed BOLD files, after dummy volume removal.",
     )
-    fmriprep_confounds_file = traits.List(
+    motion_file = traits.List(
         File(exists=True),
         desc="fMRIPrep confounds files, after dummy volume removal.",
     )
-    filtered_motion = traits.List(
-        File(exists=True),
-        desc="TSV files with filtered motion parameters, used for FD calculation.",
-    )
     temporal_mask = traits.List(
         traits.Either(
             File(exists=True),
@@ -222,8 +210,7 @@ def _run_interface(self, runtime):
         denoised_bold = self.inputs.denoised_bold
         inputs_to_filter = {
             "preprocessed_bold": self.inputs.preprocessed_bold,
-            "fmriprep_confounds_file": self.inputs.fmriprep_confounds_file,
-            "filtered_motion": self.inputs.filtered_motion,
+            "motion_file": self.inputs.motion_file,
             "temporal_mask": self.inputs.temporal_mask,
             "denoised_interpolated_bold": self.inputs.denoised_interpolated_bold,
             "censored_denoised_bold": self.inputs.censored_denoised_bold,
@@ -260,16 +247,11 @@ class _ConcatenateInputsInputSpec(BaseInterfaceInputSpec):
         mandatory=True,
         desc="Preprocessed BOLD files, after dummy volume removal.",
     )
-    fmriprep_confounds_file = traits.List(
+    motion_file = traits.List(
         File(exists=True),
         mandatory=True,
         desc="TSV files with fMRIPrep confounds for individual BOLD runs.",
     )
-    filtered_motion = traits.List(
-        File(exists=True),
-        mandatory=True,
-        desc="TSV files with filtered motion parameters, used for FD calculation.",
-    )
     temporal_mask = traits.List(
         traits.Either(
             File(exists=True),
@@ -323,14 +305,10 @@ class _ConcatenateInputsOutputSpec(TraitedSpec):
         exists=True,
         desc="Concatenated preprocessed BOLD file.",
     )
-    fmriprep_confounds_file = File(
+    motion_file = File(
         exists=True,
         desc="Concatenated TSV file with fMRIPrep confounds.",
     )
-    filtered_motion = File(
-        exists=True,
-        desc="Concatenated TSV file with filtered motion parameters, used for FD calculation.",
-    )
     temporal_mask = traits.Either(
         File(exists=True),
         Undefined,
@@ -385,14 +363,13 @@ def _run_interface(self, runtime):
             "censored_denoised_bold": self.inputs.censored_denoised_bold,
             "smoothed_denoised_bold": self.inputs.smoothed_denoised_bold,
             "timeseries_ciftis": self.inputs.timeseries_ciftis,
-            "fmriprep_confounds_file": self.inputs.fmriprep_confounds_file,
-            "filtered_motion": self.inputs.filtered_motion,
+            "motion_file": self.inputs.motion_file,
             "temporal_mask": self.inputs.temporal_mask,
             "timeseries": self.inputs.timeseries,
         }
 
         run_index, n_volumes = [], 0
-        for run_motion in self.inputs.filtered_motion[:-1]:
+        for run_motion in self.inputs.motion_file[:-1]:
             n_volumes = n_volumes + pd.read_table(run_motion).shape[0]
             run_index.append(n_volumes)
 
diff --git a/xcp_d/interfaces/nilearn.py b/xcp_d/interfaces/nilearn.py
index 63ab93b8b..d91796266 100644
--- a/xcp_d/interfaces/nilearn.py
+++ b/xcp_d/interfaces/nilearn.py
@@ -245,12 +245,15 @@ class _DenoiseImageInputSpec(BaseInterfaceInputSpec):
             "but without any additional censoring."
         ),
     )
-    confounds_file = traits.Either(
+    confounds_tsv = traits.Either(
         File(exists=True),
         None,
-        mandatory=True,
         desc="A tab-delimited file containing the confounds to remove from the BOLD data.",
     )
+    confounds_images = traits.List(
+        File(exists=True),
+        desc="A list of 4D images containing voxelwise confounds.",
+    )
     temporal_mask = File(
         exists=True,
         mandatory=True,
@@ -308,18 +311,25 @@ def _run_interface(self, runtime):
         sample_mask = ~censoring_df["framewise_displacement"].to_numpy().astype(bool)
 
         confounds_df = None
-        if self.inputs.confounds_file:
-            confounds_df = pd.read_table(self.inputs.confounds_file)
+        if self.inputs.confounds_tsv:
+            confounds_df = pd.read_table(self.inputs.confounds_tsv)
             if confounds_df.shape[0] != n_volumes:
                 raise ValueError(
                     f"Confounds file has {confounds_df.shape[0]} rows, "
                     f"but BOLD data has {n_volumes} volumes."
                 )
 
+            # Drop all-NaN columns representing voxel-wise confounds
+            confounds_df = confounds_df.dropna(axis=1, how="all")
+
+        voxelwise_confounds = None
+        if self.inputs.confounds_images:
+            voxelwise_confounds = [read_ndata(f) for f in self.inputs.confounds_images]
+
         denoised_interpolated_bold = denoise_with_nilearn(
             preprocessed_bold=preprocessed_bold_arr,
             confounds=confounds_df,
-            voxelwise_confounds=None,
+            voxelwise_confounds=voxelwise_confounds,
             sample_mask=sample_mask,
             low_pass=low_pass,
             high_pass=high_pass,
@@ -385,18 +395,27 @@ def _run_interface(self, runtime):
         sample_mask = ~censoring_df["framewise_displacement"].to_numpy().astype(bool)
 
         confounds_df = None
-        if self.inputs.confounds_file:
-            confounds_df = pd.read_table(self.inputs.confounds_file)
+        if self.inputs.confounds_tsv:
+            confounds_df = pd.read_table(self.inputs.confounds_tsv)
             if confounds_df.shape[0] != n_volumes:
                 raise ValueError(
                     f"Confounds file has {confounds_df.shape[0]} rows, "
                     f"but BOLD data has {n_volumes} volumes."
                 )
 
+            # Drop all-NaN columns representing voxel-wise confounds
+            confounds_df = confounds_df.dropna(axis=1, how="all")
+
+        voxelwise_confounds = None
+        if self.inputs.confounds_images:
+            voxelwise_confounds = []
+            for f in self.inputs.confounds_images:
+                voxelwise_confounds.append(masking.apply_mask(imgs=f, mask_img=self.inputs.mask))
+
         denoised_interpolated_bold = denoise_with_nilearn(
             preprocessed_bold=preprocessed_bold_arr,
             confounds=confounds_df,
-            voxelwise_confounds=None,
+            voxelwise_confounds=voxelwise_confounds,
             sample_mask=sample_mask,
             low_pass=low_pass,
             high_pass=high_pass,
diff --git a/xcp_d/interfaces/plotting.py b/xcp_d/interfaces/plotting.py
index 780e5407e..d7f4dfcc6 100644
--- a/xcp_d/interfaces/plotting.py
+++ b/xcp_d/interfaces/plotting.py
@@ -28,9 +28,7 @@
 from nipype.interfaces.fsl.base import FSLCommand, FSLCommandInputSpec
 from templateflow.api import get as get_template
 
-from xcp_d.utils.confounds import load_motion
 from xcp_d.utils.filemanip import fname_presuffix
-from xcp_d.utils.modified_data import compute_fd
 from xcp_d.utils.plotting import FMRIPlot, plot_fmri_es, surf_data_from_cifti
 from xcp_d.utils.qcmetrics import compute_dvars
 from xcp_d.utils.write_save import read_ndata
@@ -39,8 +37,7 @@
 
 
 class _CensoringPlotInputSpec(BaseInterfaceInputSpec):
-    fmriprep_confounds_file = File(exists=True, mandatory=True, desc="fMRIPrep confounds file.")
-    filtered_motion = File(exists=True, mandatory=True, desc="Filtered motion file.")
+    motion_file = File(exists=True, mandatory=True, desc="fMRIPrep confounds file.")
     temporal_mask = File(
         exists=True,
         mandatory=True,
@@ -70,16 +67,8 @@ class CensoringPlot(SimpleInterface):
 
     def _run_interface(self, runtime):
         # Load confound matrix and load motion with motion filtering
-        confounds_df = pd.read_table(self.inputs.fmriprep_confounds_file)
-        preproc_motion_df = load_motion(
-            confounds_df.copy(),
-            TR=self.inputs.TR,
-            motion_filter_type=None,
-        )
-        preproc_fd_timeseries = compute_fd(
-            confound=preproc_motion_df,
-            head_radius=self.inputs.head_radius,
-        )
+        motion_df = pd.read_table(self.inputs.motion_file)
+        preproc_fd_timeseries = motion_df["framewise_displacement"].values
 
         # Load temporal mask
         censoring_df = pd.read_table(self.inputs.temporal_mask)
@@ -120,13 +109,11 @@ def _run_interface(self, runtime):
 
         # Compute filtered framewise displacement to plot censoring
         if self.inputs.motion_filter_type:
-            filtered_fd_timeseries = pd.read_table(self.inputs.filtered_motion)[
-                "framewise_displacement"
-            ]
+            filtered_fd_timeseries = motion_df["framewise_displacement_filtered"].values
 
             ax.plot(
                 time_array,
-                filtered_fd_timeseries.values,
+                filtered_fd_timeseries,
                 label="Filtered Framewise Displacement",
                 color=palette[2],
             )
@@ -214,7 +201,7 @@ class _QCPlotsInputSpec(BaseInterfaceInputSpec):
         Undefined,
         desc="Temporal mask",
     )
-    fmriprep_confounds_file = File(
+    motion_file = File(
         exists=True,
         mandatory=True,
         desc="fMRIPrep confounds file, after dummy scans removal",
@@ -268,16 +255,11 @@ class QCPlots(SimpleInterface):
 
     def _run_interface(self, runtime):
         # Load confound matrix and load motion without motion filtering
-        confounds_df = pd.read_table(self.inputs.fmriprep_confounds_file)
-        preproc_motion_df = load_motion(
-            confounds_df.copy(),
-            TR=self.inputs.TR,
-            motion_filter_type=None,
-        )
-        preproc_fd_timeseries = compute_fd(
-            confound=preproc_motion_df,
-            head_radius=self.inputs.head_radius,
-        )
+        motion_df = pd.read_table(self.inputs.motion_file)
+        if "framewise_displacement_filtered" in motion_df.columns:
+            preproc_fd_timeseries = motion_df["framewise_displacement_filtered"].values
+        else:
+            preproc_fd_timeseries = motion_df["framewise_displacement"].values
 
         # Determine number of dummy volumes and load temporal mask
         if isdefined(self.inputs.temporal_mask):
@@ -376,7 +358,7 @@ class _QCPlotsESInputSpec(BaseInterfaceInputSpec):
         mandatory=True,
         desc="Data after filtering, interpolation, etc. This is not plotted.",
     )
-    filtered_motion = File(
+    motion_file = File(
         exists=True,
         mandatory=True,
         desc="TSV file with filtered motion parameters.",
@@ -460,7 +442,7 @@ def _run_interface(self, runtime):
             preprocessed_bold=self.inputs.preprocessed_bold,
             denoised_interpolated_bold=self.inputs.denoised_interpolated_bold,
             TR=self.inputs.TR,
-            filtered_motion=self.inputs.filtered_motion,
+            motion_file=self.inputs.motion_file,
             temporal_mask=self.inputs.temporal_mask,
             preprocessed_figure=preprocessed_figure,
             denoised_figure=denoised_figure,
diff --git a/xcp_d/interfaces/utils.py b/xcp_d/interfaces/utils.py
index 2a1ce2b32..d2c05e581 100644
--- a/xcp_d/interfaces/utils.py
+++ b/xcp_d/interfaces/utils.py
@@ -19,9 +19,8 @@
     traits_extension,
 )
 
-from xcp_d.utils.confounds import load_motion
 from xcp_d.utils.filemanip import fname_presuffix
-from xcp_d.utils.modified_data import compute_fd, downcast_to_32
+from xcp_d.utils.modified_data import downcast_to_32
 from xcp_d.utils.qcmetrics import compute_dvars, compute_registration_qc
 from xcp_d.utils.write_save import read_ndata
 
@@ -172,7 +171,7 @@ class _LINCQCInputSpec(BaseInterfaceInputSpec):
         Undefined,
         desc="Temporal mask",
     )
-    fmriprep_confounds_file = File(
+    motion_file = File(
         exists=True,
         mandatory=True,
         desc="fMRIPrep confounds file, after dummy scans removal",
@@ -245,14 +244,9 @@ class LINCQC(SimpleInterface):
 
     def _run_interface(self, runtime):
         # Load confound matrix and load motion without motion filtering
-        confounds_df = pd.read_table(self.inputs.fmriprep_confounds_file)
-        preproc_motion_df = load_motion(
-            confounds_df.copy(),
-            TR=self.inputs.TR,
-            motion_filter_type=None,
-        )
-        preproc_fd = compute_fd(confound=preproc_motion_df, head_radius=self.inputs.head_radius)
-        rmsd = confounds_df["rmsd"].to_numpy()
+        motion_df = pd.read_table(self.inputs.motion_file)
+        preproc_fd = motion_df["framewise_displacement"].to_numpy()
+        rmsd = motion_df["rmsd"].to_numpy()
 
         # Determine number of dummy volumes and load temporal mask
         dummy_scans = self.inputs.dummy_scans
@@ -329,7 +323,7 @@ def _run_interface(self, runtime):
                     "This value includes high-motion outliers, but not dummy volumes. "
                     "FD is calculated according to the Power definition."
                 ),
-                "Units": "mm / volume",
+                "Units": "mm",
                 "Term URL": "https://doi.org/10.1016/j.neuroimage.2011.10.018",
             },
             "mean_fd_post_censoring": {
@@ -339,7 +333,7 @@ def _run_interface(self, runtime):
                     "This value does not include high-motion outliers or dummy volumes. "
                     "FD is calculated according to the Power definition."
                 ),
-                "Units": "mm / volume",
+                "Units": "mm",
                 "Term URL": "https://doi.org/10.1016/j.neuroimage.2011.10.018",
             },
             "mean_relative_rms": {
@@ -451,7 +445,7 @@ def _run_interface(self, runtime):
 
 
 class _ABCCQCInputSpec(BaseInterfaceInputSpec):
-    filtered_motion = File(
+    motion_file = File(
         exists=True,
         mandatory=True,
         desc="",
@@ -493,15 +487,18 @@ def _run_interface(self, runtime):
         TR = self.inputs.TR
 
         self._results["qc_file"] = fname_presuffix(
-            self.inputs.filtered_motion,
+            self.inputs.motion_file,
             suffix="qc_bold.hdf5",
             newpath=runtime.cwd,
             use_ext=False,
         )
 
         # Load filtered framewise_displacement values from file
-        filtered_motion_df = pd.read_table(self.inputs.filtered_motion)
-        fd = filtered_motion_df["framewise_displacement"].values
+        motion_df = pd.read_table(self.inputs.motion_file)
+        if "framewise_displacement_filtered" in motion_df.columns:
+            fd = motion_df["framewise_displacement_filtered"].values
+        else:
+            fd = motion_df["framewise_displacement"].values
 
         with h5py.File(self._results["qc_file"], "w") as dcan:
             for thresh in np.linspace(0, 1, 101):
diff --git a/xcp_d/tests/conftest.py b/xcp_d/tests/conftest.py
index ab09caf25..bf80131e0 100644
--- a/xcp_d/tests/conftest.py
+++ b/xcp_d/tests/conftest.py
@@ -59,7 +59,8 @@ def output_dir(request):
 def datasets(data_dir):
     """Locate downloaded datasets."""
     dsets = {}
-    dsets["ds001419"] = os.path.join(data_dir, "ds001419-fmriprep")
+    dsets["ds001419"] = os.path.join(data_dir, "ds001419", "ds001419")
+    dsets["ds001419-aroma"] = os.path.join(data_dir, "ds001419-aroma", "ds001419-aroma")
     dsets["pnc"] = os.path.join(data_dir, "pnc")
     dsets["nibabies"] = os.path.join(data_dir, "nibabies/derivatives/nibabies")
     dsets["fmriprep_without_freesurfer"] = os.path.join(
@@ -81,7 +82,7 @@ def ds001419_data(datasets):
     files = {}
     files["nifti_file"] = os.path.join(
         func_dir,
-        "sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-preproc_bold.nii.gz",
+        "sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-preproc_bold.nii.gz",
     )
     files["cifti_file"] = os.path.join(
         func_dir,
@@ -93,7 +94,7 @@ def ds001419_data(datasets):
     )
     files["brain_mask_file"] = os.path.join(
         func_dir,
-        "sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-brain_mask.nii.gz",
+        "sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-brain_mask.nii.gz",
     )
     files["confounds_file"] = os.path.join(
         func_dir,
@@ -105,21 +106,21 @@ def ds001419_data(datasets):
     )
     files["anat_to_template_xfm"] = os.path.join(
         anat_dir,
-        "sub-01_from-T1w_to-MNI152NLin2009cAsym_mode-image_xfm.h5",
+        "sub-01_from-T1w_to-MNI152NLin6Asym_mode-image_xfm.h5",
     )
     files["template_to_anat_xfm"] = os.path.join(
         anat_dir,
-        "sub-01_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5",
+        "sub-01_from-MNI152NLin6Asym_to-T1w_mode-image_xfm.h5",
     )
     files["boldref"] = os.path.join(
         func_dir,
-        "sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_boldref.nii.gz",
+        "sub-01_task-rest_space-MNI152NLin6Asym_res-2_boldref.nii.gz",
     )
     files["boldref_t1w"] = os.path.join(func_dir, "sub-01_task-rest_space-T1w_boldref.nii.gz")
     files["t1w"] = os.path.join(anat_dir, "sub-01_desc-preproc_T1w.nii.gz")
     files["t1w_mni"] = os.path.join(
         anat_dir,
-        "sub-01_space-MNI152NLin2009cAsym_res-2_desc-preproc_T1w.nii.gz",
+        "sub-01_space-MNI152NLin6Asym_res-2_desc-preproc_T1w.nii.gz",
     )
 
     return files
@@ -146,7 +147,7 @@ def pnc_data(datasets):
     )
     files["brain_mask_file"] = os.path.join(
         func_dir,
-        "sub-1648798153_ses-PNC1_task-rest_space-MNI152NLin2009cAsym_res-2_desc-brain_mask.nii.gz",
+        "sub-1648798153_ses-PNC1_task-rest_space-MNI152NLin6Asym_res-2_desc-brain_mask.nii.gz",
     )
     files["confounds_file"] = os.path.join(
         func_dir,
@@ -158,25 +159,28 @@ def pnc_data(datasets):
     )
     files["anat_to_template_xfm"] = os.path.join(
         anat_dir,
-        "sub-1648798153_ses-PNC1_acq-refaced_from-T1w_to-MNI152NLin2009cAsym_mode-image_xfm.h5",
+        "sub-1648798153_ses-PNC1_acq-refaced_from-T1w_to-MNI152NLin6Asym_mode-image_xfm.h5",
     )
     files["template_to_anat_xfm"] = os.path.join(
         anat_dir,
-        "sub-1648798153_ses-PNC1_acq-refaced_from-MNI152NLin2009cAsym_to-T1w_mode-image_xfm.h5",
+        "sub-1648798153_ses-PNC1_acq-refaced_from-MNI152NLin6Asym_to-T1w_mode-image_xfm.h5",
     )
     files["boldref"] = os.path.join(
         func_dir,
-        "sub-1648798153_ses-PNC1_task-rest_space-MNI152NLin2009cAsym_res-2_boldref.nii.gz",
+        "sub-1648798153_ses-PNC1_task-rest_space-MNI152NLin6Asym_res-2_boldref.nii.gz",
     )
-    files["boldref_t1w"] = os.path.join(
-        func_dir,
-        "sub-1648798153_ses-PNC1_task-rest_space-T1w_boldref.nii.gz",
+    files["anat_mask"] = os.path.join(
+        anat_dir,
+        "sub-1648798153_ses-PNC1_acq-refaced_desc-brain_mask.nii.gz",
+    )
+    files["t1w"] = os.path.join(
+        anat_dir,
+        "sub-1648798153_ses-PNC1_acq-refaced_desc-preproc_T1w.nii.gz",
     )
-    files["t1w"] = os.path.join(anat_dir, "sub-1648798153_acq-refaced_desc-preproc_T1w.nii.gz")
     files["t1w_mni"] = os.path.join(
         anat_dir,
         (
-            "sub-1648798153_ses-PNC1_acq-refaced_space-MNI152NLin2009cAsym_"
+            "sub-1648798153_ses-PNC1_acq-refaced_space-MNI152NLin6Asym_"
             "res-2_desc-preproc_T1w.nii.gz"
         ),
     )
diff --git a/xcp_d/tests/data/ds001419_nifti_filter.json b/xcp_d/tests/data/ds001419_nifti_filter.json
index ae13e824b..f3cc70c7a 100644
--- a/xcp_d/tests/data/ds001419_nifti_filter.json
+++ b/xcp_d/tests/data/ds001419_nifti_filter.json
@@ -2,7 +2,7 @@
     "bold": {
         "task": ["imagery", "rest"],
         "run": ["01", "02", null],
-        "space": "MNI152NLin2009cAsym",
+        "space": "MNI152NLin6Asym",
         "res": "2"
     }
 }
diff --git a/xcp_d/tests/data/test_ds001419_cifti_outputs.txt b/xcp_d/tests/data/test_ds001419_cifti_outputs.txt
index 5d4050a8d..a9c124110 100644
--- a/xcp_d/tests/data/test_ds001419_cifti_outputs.txt
+++ b/xcp_d/tests/data/test_ds001419_cifti_outputs.txt
@@ -26,18 +26,30 @@ logs/CITATION.tex
 sub-01
 sub-01.html
 sub-01/anat
-sub-01/anat/sub-01_space-MNI152NLin2009cAsym_desc-preproc_T1w.nii.gz
+sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.nii.gz
+sub-01/anat/sub-01_space-fsLR_seg-4S156Parcels_stat-mean_desc-curv_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S156Parcels_stat-mean_desc-sulc_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S156Parcels_stat-mean_desc-thickness_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S256Parcels_stat-mean_desc-curv_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S256Parcels_stat-mean_desc-sulc_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S256Parcels_stat-mean_desc-thickness_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S356Parcels_stat-mean_desc-curv_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S356Parcels_stat-mean_desc-sulc_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S356Parcels_stat-mean_desc-thickness_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S456Parcels_stat-mean_desc-curv_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S456Parcels_stat-mean_desc-sulc_morph.tsv
+sub-01/anat/sub-01_space-fsLR_seg-4S456Parcels_stat-mean_desc-thickness_morph.tsv
 sub-01/func
 sub-01/func/sub-01_task-imagery_desc-abcc_qc.hdf5
-sub-01/func/sub-01_task-imagery_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_desc-filtered_motion.tsv
+sub-01/func/sub-01_task-imagery_motion.json
+sub-01/func/sub-01_task-imagery_motion.tsv
 sub-01/func/sub-01_task-imagery_outliers.json
 sub-01/func/sub-01_task-imagery_outliers.tsv
 sub-01/func/sub-01_task-imagery_run-01_desc-abcc_qc.hdf5
-sub-01/func/sub-01_task-imagery_run-01_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_run-01_desc-filtered_motion.tsv
 sub-01/func/sub-01_task-imagery_run-01_design.json
 sub-01/func/sub-01_task-imagery_run-01_design.tsv
+sub-01/func/sub-01_task-imagery_run-01_motion.json
+sub-01/func/sub-01_task-imagery_run-01_motion.tsv
 sub-01/func/sub-01_task-imagery_run-01_outliers.json
 sub-01/func/sub-01_task-imagery_run-01_outliers.tsv
 sub-01/func/sub-01_task-imagery_run-01_space-fsLR_den-91k_desc-denoisedSmoothed_bold.dtseries.nii
@@ -120,10 +132,10 @@ sub-01/func/sub-01_task-imagery_run-01_space-fsLR_seg-4S456Parcels_stat-pearsonc
 sub-01/func/sub-01_task-imagery_run-01_space-fsLR_seg-4S456Parcels_stat-reho_bold.json
 sub-01/func/sub-01_task-imagery_run-01_space-fsLR_seg-4S456Parcels_stat-reho_bold.tsv
 sub-01/func/sub-01_task-imagery_run-02_desc-abcc_qc.hdf5
-sub-01/func/sub-01_task-imagery_run-02_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_run-02_desc-filtered_motion.tsv
 sub-01/func/sub-01_task-imagery_run-02_design.json
 sub-01/func/sub-01_task-imagery_run-02_design.tsv
+sub-01/func/sub-01_task-imagery_run-02_motion.json
+sub-01/func/sub-01_task-imagery_run-02_motion.tsv
 sub-01/func/sub-01_task-imagery_run-02_outliers.json
 sub-01/func/sub-01_task-imagery_run-02_outliers.tsv
 sub-01/func/sub-01_task-imagery_run-02_space-fsLR_den-91k_desc-denoisedSmoothed_bold.dtseries.nii
diff --git a/xcp_d/tests/data/test_ds001419_nifti_outputs.txt b/xcp_d/tests/data/test_ds001419_nifti_outputs.txt
index 733e115b3..d1d0ef92e 100644
--- a/xcp_d/tests/data/test_ds001419_nifti_outputs.txt
+++ b/xcp_d/tests/data/test_ds001419_nifti_outputs.txt
@@ -8,64 +8,64 @@ logs/CITATION.tex
 sub-01
 sub-01.html
 sub-01/anat
-sub-01/anat/sub-01_space-MNI152NLin2009cAsym_desc-preproc_T1w.nii.gz
+sub-01/anat/sub-01_space-MNI152NLin6Asym_desc-preproc_T1w.nii.gz
 sub-01/func
-sub-01/func/sub-01_task-imagery_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_desc-filtered_motion.tsv
+sub-01/func/sub-01_task-imagery_motion.json
+sub-01/func/sub-01_task-imagery_motion.tsv
 sub-01/func/sub-01_task-imagery_outliers.json
 sub-01/func/sub-01_task-imagery_outliers.tsv
-sub-01/func/sub-01_task-imagery_run-01_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_run-01_desc-filtered_motion.tsv
 sub-01/func/sub-01_task-imagery_run-01_desc-preproc_design.json
 sub-01/func/sub-01_task-imagery_run-01_desc-preproc_design.tsv
+sub-01/func/sub-01_task-imagery_run-01_motion.json
+sub-01/func/sub-01_task-imagery_run-01_motion.tsv
 sub-01/func/sub-01_task-imagery_run-01_outliers.json
 sub-01/func/sub-01_task-imagery_run-01_outliers.tsv
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_desc-linc_qc.tsv
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.json
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.nii.gz
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.json
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.nii.gz
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.json
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.json
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.json
-sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_run-02_desc-filtered_motion.json
-sub-01/func/sub-01_task-imagery_run-02_desc-filtered_motion.tsv
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_desc-linc_qc.tsv
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.json
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.nii.gz
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_desc-denoised_bold.json
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_desc-denoised_bold.nii.gz
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.json
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.nii.gz
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.json
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.json
+sub-01/func/sub-01_task-imagery_run-01_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.nii.gz
 sub-01/func/sub-01_task-imagery_run-02_desc-preproc_design.json
 sub-01/func/sub-01_task-imagery_run-02_desc-preproc_design.tsv
+sub-01/func/sub-01_task-imagery_run-02_motion.json
+sub-01/func/sub-01_task-imagery_run-02_motion.tsv
 sub-01/func/sub-01_task-imagery_run-02_outliers.json
 sub-01/func/sub-01_task-imagery_run-02_outliers.tsv
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_desc-linc_qc.tsv
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.json
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.nii.gz
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.json
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.nii.gz
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.json
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.json
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.json
-sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.nii.gz
-sub-01/func/sub-01_task-imagery_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.json
-sub-01/func/sub-01_task-imagery_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.nii.gz
-sub-01/func/sub-01_task-imagery_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.json
-sub-01/func/sub-01_task-imagery_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.nii.gz
-sub-01/func/sub-01_task-rest_desc-filtered_motion.json
-sub-01/func/sub-01_task-rest_desc-filtered_motion.tsv
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_desc-linc_qc.tsv
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.json
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.nii.gz
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_desc-denoised_bold.json
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_desc-denoised_bold.nii.gz
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.json
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.nii.gz
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.json
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.json
+sub-01/func/sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.nii.gz
+sub-01/func/sub-01_task-imagery_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.json
+sub-01/func/sub-01_task-imagery_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.nii.gz
+sub-01/func/sub-01_task-imagery_space-MNI152NLin6Asym_res-2_desc-denoised_bold.json
+sub-01/func/sub-01_task-imagery_space-MNI152NLin6Asym_res-2_desc-denoised_bold.nii.gz
 sub-01/func/sub-01_task-rest_desc-preproc_design.json
 sub-01/func/sub-01_task-rest_desc-preproc_design.tsv
+sub-01/func/sub-01_task-rest_motion.json
+sub-01/func/sub-01_task-rest_motion.tsv
 sub-01/func/sub-01_task-rest_outliers.json
 sub-01/func/sub-01_task-rest_outliers.tsv
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_desc-linc_qc.tsv
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.json
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-denoisedSmoothed_bold.nii.gz
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.json
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_desc-denoised_bold.nii.gz
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.json
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-alff_boldmap.nii.gz
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.json
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.json
-sub-01/func/sub-01_task-rest_space-MNI152NLin2009cAsym_res-2_stat-reho_boldmap.nii.gz
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_desc-linc_qc.tsv
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.json
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-denoisedSmoothed_bold.nii.gz
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-denoised_bold.json
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_desc-denoised_bold.nii.gz
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.json
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-alff_boldmap.nii.gz
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.json
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-alff_desc-smooth_boldmap.nii.gz
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.json
+sub-01/func/sub-01_task-rest_space-MNI152NLin6Asym_res-2_stat-reho_boldmap.nii.gz
diff --git a/xcp_d/tests/data/test_pnc_cifti_outputs.txt b/xcp_d/tests/data/test_pnc_cifti_outputs.txt
index 47e07289e..41c5cae2a 100644
--- a/xcp_d/tests/data/test_pnc_cifti_outputs.txt
+++ b/xcp_d/tests/data/test_pnc_cifti_outputs.txt
@@ -41,10 +41,10 @@ sub-1648798153/ses-PNC1/anat/sub-1648798153_ses-PNC1_acq-refaced_space-fsLR_seg-
 sub-1648798153/ses-PNC1/anat/sub-1648798153_ses-PNC1_acq-refaced_space-fsLR_seg-MyersLabonte_stat-mean_desc-thickness_morph.tsv
 sub-1648798153/ses-PNC1/func
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_desc-abcc_qc.hdf5
-sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_desc-filtered_motion.json
-sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_desc-filtered_motion.tsv
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_design.json
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_design.tsv
+sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_motion.json
+sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_motion.tsv
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_outliers.json
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_outliers.tsv
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-rest_acq-singleband_space-fsLR_den-91k_desc-denoisedSmoothed_bold.dtseries.nii
diff --git a/xcp_d/tests/data/test_pnc_cifti_t2wonly_outputs.txt b/xcp_d/tests/data/test_pnc_cifti_t2wonly_outputs.txt
index a93adf86e..c8ae9972e 100644
--- a/xcp_d/tests/data/test_pnc_cifti_t2wonly_outputs.txt
+++ b/xcp_d/tests/data/test_pnc_cifti_t2wonly_outputs.txt
@@ -40,8 +40,8 @@ sub-1648798153/ses-PNC1/anat/sub-1648798153_ses-PNC1_acq-refaced_space-fsLR_seg-
 sub-1648798153/ses-PNC1/anat/sub-1648798153_ses-PNC1_acq-refaced_space-fsLR_seg-MIDB_stat-mean_desc-thickness_morph.tsv
 sub-1648798153/ses-PNC1/func
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_desc-abcc_qc.hdf5
-sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_desc-filtered_motion.json
-sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_desc-filtered_motion.tsv
+sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_motion.json
+sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_motion.tsv
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_outliers.json
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_outliers.tsv
 sub-1648798153/ses-PNC1/func/sub-1648798153_ses-PNC1_task-idemo_space-fsLR_den-91k_desc-denoisedSmoothed_bold.dtseries.nii
diff --git a/xcp_d/tests/data/test_ukbiobank_outputs.txt b/xcp_d/tests/data/test_ukbiobank_outputs.txt
index a01e873fa..0d94a8fc4 100644
--- a/xcp_d/tests/data/test_ukbiobank_outputs.txt
+++ b/xcp_d/tests/data/test_ukbiobank_outputs.txt
@@ -69,10 +69,10 @@ sub-0000001/ses-01
 sub-0000001/ses-01/anat
 sub-0000001/ses-01/anat/sub-0000001_ses-01_space-MNI152NLin6Asym_desc-preproc_T1w.nii.gz
 sub-0000001/ses-01/func
-sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_desc-filtered_motion.json
-sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_desc-filtered_motion.tsv
 sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_desc-preproc_design.json
 sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_desc-preproc_design.tsv
+sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_motion.json
+sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_motion.tsv
 sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_outliers.json
 sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_outliers.tsv
 sub-0000001/ses-01/func/sub-0000001_ses-01_task-rest_space-MNI152NLin6Asym_desc-denoisedSmoothed_bold.json
diff --git a/xcp_d/tests/test_TR.py b/xcp_d/tests/test_TR.py
deleted file mode 100644
index 858b9651b..000000000
--- a/xcp_d/tests/test_TR.py
+++ /dev/null
@@ -1,195 +0,0 @@
-"""Tests for removing volumes from files.
-
-This file is an example of running pytests either locally or on circleci.
-
-Arguments have to be passed to these functions because the data may be
-mounted in a container somewhere unintuitively.
-"""
-
-import os.path as op
-
-import nibabel as nb
-import pandas as pd
-
-from xcp_d.interfaces.censoring import RemoveDummyVolumes
-
-
-def test_removedummyvolumes_nifti(ds001419_data, tmp_path_factory):
-    """Test RemoveDummyVolumes() for NIFTI input data."""
-    # Define inputs
-    temp_dir = tmp_path_factory.mktemp("test_RemoveDummyVolumes_nifti")
-
-    boldfile = ds001419_data["nifti_file"]
-    confounds_file = ds001419_data["confounds_file"]
-
-    # Find the original number of volumes acc. to nifti & confounds timeseries
-    original_confounds = pd.read_table(confounds_file)
-    original_nvols_nifti = nb.load(boldfile).shape[3]
-
-    # Test a nifti file with 0 volumes to remove
-    remove_nothing = RemoveDummyVolumes(
-        bold_file=boldfile,
-        fmriprep_confounds_file=confounds_file,
-        confounds_file=confounds_file,
-        motion_file=confounds_file,
-        temporal_mask=confounds_file,
-        dummy_scans=0,
-    )
-    results = remove_nothing.run(cwd=temp_dir)
-    undropped_confounds = pd.read_table(results.outputs.fmriprep_confounds_file_dropped_TR)
-    # Were the files created?
-    assert op.exists(results.outputs.bold_file_dropped_TR)
-    assert op.exists(results.outputs.fmriprep_confounds_file_dropped_TR)
-    # Have the confounds stayed the same shape?
-    assert undropped_confounds.shape == original_confounds.shape
-    # Has the nifti stayed the same shape?
-    assert (
-        nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3] == original_nvols_nifti
-    )
-
-    # Test a nifti file with 1-10 volumes to remove
-    for n in range(10):
-        remove_n_vols = RemoveDummyVolumes(
-            bold_file=boldfile,
-            fmriprep_confounds_file=confounds_file,
-            confounds_file=confounds_file,
-            motion_file=confounds_file,
-            temporal_mask=confounds_file,
-            dummy_scans=n,
-        )
-        results = remove_n_vols.run(cwd=temp_dir)
-        dropped_confounds = pd.read_table(results.outputs.fmriprep_confounds_file_dropped_TR)
-        # Were the files created?
-        assert op.exists(results.outputs.bold_file_dropped_TR)
-        assert op.exists(results.outputs.fmriprep_confounds_file_dropped_TR)
-        # Have the confounds changed correctly?
-        assert dropped_confounds.shape[0] == original_confounds.shape[0] - n
-        # Has the nifti changed correctly?
-        try:
-            assert (
-                nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3]
-                == original_nvols_nifti - n
-            )
-        except Exception as exc:
-            exc = nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3]
-            print(f"Tests failing at N = {n}.")
-            raise Exception(f"Number of volumes in dropped nifti is {exc}.")
-
-
-def test_removedummyvolumes_cifti(ds001419_data, tmp_path_factory):
-    """Test RemoveDummyVolumes() for CIFTI input data."""
-    # Define inputs
-    temp_dir = tmp_path_factory.mktemp("test_RemoveDummyVolumes_cifti")
-
-    boldfile = ds001419_data["cifti_file"]
-    confounds_file = ds001419_data["confounds_file"]
-
-    # Find the original number of volumes acc. to cifti & confounds timeseries
-    original_confounds = pd.read_table(confounds_file)
-    original_nvols_cifti = nb.load(boldfile).shape[0]
-
-    # Test a cifti file with 0 volumes to remove
-    remove_nothing = RemoveDummyVolumes(
-        bold_file=boldfile,
-        fmriprep_confounds_file=confounds_file,
-        confounds_file=confounds_file,
-        motion_file=confounds_file,
-        temporal_mask=confounds_file,
-        dummy_scans=0,
-    )
-    results = remove_nothing.run(cwd=temp_dir)
-    undropped_confounds = pd.read_table(results.outputs.fmriprep_confounds_file_dropped_TR)
-    # Were the files created?
-    assert op.exists(results.outputs.bold_file_dropped_TR)
-    assert op.exists(results.outputs.fmriprep_confounds_file_dropped_TR)
-    # Have the confounds stayed the same shape?
-    assert undropped_confounds.shape == original_confounds.shape
-    # Has the cifti stayed the same shape?
-    assert (
-        nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0] == original_nvols_cifti
-    )
-
-    # Test a cifti file with 1-10 volumes to remove
-    for n in range(10):
-        remove_n_vols = RemoveDummyVolumes(
-            bold_file=boldfile,
-            fmriprep_confounds_file=confounds_file,
-            confounds_file=confounds_file,
-            motion_file=confounds_file,
-            temporal_mask=confounds_file,
-            dummy_scans=n,
-        )
-
-        results = remove_n_vols.run(cwd=temp_dir)
-        dropped_confounds = pd.read_table(results.outputs.fmriprep_confounds_file_dropped_TR)
-        # Were the files created?
-        assert op.exists(results.outputs.bold_file_dropped_TR)
-        assert op.exists(results.outputs.fmriprep_confounds_file_dropped_TR)
-        # Have the confounds changed correctly?
-        assert dropped_confounds.shape[0] == original_confounds.shape[0] - n
-        # Has the cifti changed correctly?
-        try:
-            assert (
-                nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0]
-                == original_nvols_cifti - n
-            )
-        except Exception as exc:
-            exc = nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0]
-            print(f"Tests failing at N = {n}.")
-            raise Exception(f"Number of volumes in dropped cifti is {exc}.")
-
-
-# Testing with CUSTOM CONFOUNDS
-# Note: I had to test this locally as I don't have the permissions to share the
-# data I used here at the moment.
-# def test_fd_interface_cifti_custom(ds001419_data):  # Checking results
-#     boldfile = ds001419_data["cifti_file"]
-#     confounds_file = ds001419_data["confounds_file"]
-#     custom_confounds_tsv = data_dir + "/fmriprep/sub-colornest001/ses-1/func/customcifti.tsv"
-
-#     # Run workflow
-#     remvtr = RemoveDummyVolumes()
-#     remvtr.inputs.bold_file = boldfile
-#     remvtr.inputs.fmriprep_confounds_file = confounds_tsv
-#     remvtr.inputs.custom_confounds = custom_confounds_tsv
-#     remvtr.inputs.dummy_scans = 5
-#     results = remvtr.run(cwd=temp_dir)
-
-#     # Load in dropped image and confounds tsv
-#     dropped_image = nb.load(results.outputs.bold_file_dropped_TR)
-#     dropped_confounds_timeseries = pd.read_table(results.outputs.custom_confounds_dropped)
-
-#     # Assert the length of the confounds is the same as the nvol of the image
-#     try:
-#         assert len(dropped_confounds_timeseries) == dropped_image.get_fdata().shape[0]
-#         print(len(dropped_confounds_timeseries))
-#     except Exception as exc:
-#         exc = len(dropped_confounds_timeseries), dropped_image.get_fdata().shape[0]
-#         raise Exception(f"Sorry, the shapes are: {exc}.")
-
-
-# def test_fd_interface_nifti_custom(data_dir):  # Checking results
-#     boldfile = data_dir + "sub-01/func/" \
-#         "sub-01_task-mixedgamblestask_run-1_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz"
-#     confounds_file = data_dir + "sub-01/func/" \
-#         "sub-01_task-mixedgamblestask_run-1_desc-confounds_timeseries.tsv"
-#     custom_confounds_tsv = data_dir + "sub-01/func/customnifti.tsv"
-#     # Run workflow
-#     remvtr = RemoveDummyVolumes()
-#     remvtr.inputs.bold_file = boldfile
-#     remvtr.inputs.fmriprep_confounds_file = confounds_tsv
-#     remvtr.inputs.custom_confounds = custom_confounds_tsv
-#     remvtr.inputs.dummy_scans = 5
-#     results = remvtr.run(cwd=temp_dir)
-
-#     # Load in dropped image and confounds tsv
-#     dropped_image = nb.load(results.outputs.bold_file_dropped_TR)
-#     dropped_confounds_timeseries = pd.read_table(results.outputs.custom_confounds_dropped)
-
-#     # Assert the length of the confounds is the same as the nvol of the image
-#     try:
-#         assert len(dropped_confounds_timeseries) == dropped_image.get_fdata().shape[3]
-#         print(len(dropped_confounds_timeseries))
-#     except Exception as exc:
-#         exc = len(dropped_confounds_timeseries), dropped_image.get_fdata().shape[3]
-#         raise Exception(f"Sorry, the shapes are: {exc}.")
diff --git a/xcp_d/tests/test_cli.py b/xcp_d/tests/test_cli.py
index 3a92c9560..0758f0de7 100644
--- a/xcp_d/tests/test_cli.py
+++ b/xcp_d/tests/test_cli.py
@@ -18,11 +18,14 @@
     check_affines,
     check_generated_files,
     download_test_data,
-    update_resources,
     get_test_data_path,
     list_files,
+    update_resources,
+)
+from xcp_d.utils.bids import (
+    write_atlas_dataset_description,
+    write_derivative_description,
 )
-from xcp_d.utils.bids import write_atlas_dataset_description, write_derivative_description
 
 LOGGER = logging.getLogger("nipype.utils")
 
@@ -34,6 +37,7 @@ def test_ds001419_nifti(data_dir, output_dir, working_dir):
     test_name = "test_ds001419_nifti"
 
     dataset_dir = download_test_data("ds001419", data_dir)
+    derivs_dir = download_test_data("ds001419-aroma", data_dir)
     out_dir = os.path.join(output_dir, test_name)
     work_dir = os.path.join(working_dir, test_name)
 
@@ -45,6 +49,8 @@ def test_ds001419_nifti(data_dir, output_dir, working_dir):
         out_dir,
         "participant",
         "--mode=none",
+        "--derivatives",
+        f"aroma={derivs_dir}",
         f"-w={work_dir}",
         f"--bids-filter-file={filter_file}",
         "--nuisance-regressors=aroma_gsr",
@@ -284,22 +290,9 @@ def test_fmriprep_without_freesurfer(data_dir, output_dir, working_dir):
     test_name = "test_fmriprep_without_freesurfer"
 
     dataset_dir = download_test_data("fmriprepwithoutfreesurfer", data_dir)
-    temp_dir = os.path.join(output_dir, test_name)
-    out_dir = os.path.join(temp_dir, "xcp_d")
+    tmpdir = os.path.join(output_dir, test_name)
+    out_dir = os.path.join(tmpdir, "xcp_d")
     work_dir = os.path.join(working_dir, test_name)
-    custom_confounds_dir = os.path.join(temp_dir, "custom_confounds")
-    os.makedirs(custom_confounds_dir, exist_ok=True)
-
-    # Create custom confounds folder
-    for run_number in [1, 2]:
-        out_file = f"sub-01_task-mixedgamblestask_run-{run_number}_desc-confounds_timeseries.tsv"
-        out_file = os.path.join(custom_confounds_dir, out_file)
-        confounds_df = pd.DataFrame(
-            columns=["a", "b"],
-            data=np.random.random((16, 2)),
-        )
-        confounds_df.to_csv(out_file, sep="\t", index=False)
-        LOGGER.warning(f"Created custom confounds file at {out_file}.")
 
     parameters = [
         dataset_dir,
@@ -317,7 +310,6 @@ def test_fmriprep_without_freesurfer(data_dir, output_dir, working_dir):
         "--disable-bandpass-filter",
         "--min-time=20",
         "--dummy-scans=1",
-        f"--custom_confounds={custom_confounds_dir}",
         "--abcc-qc",
     ]
 
@@ -330,13 +322,6 @@ def test_fmriprep_without_freesurfer(data_dir, output_dir, working_dir):
     # Run combine-qc too
     combineqc.main([out_dir, "summary"])
 
-    dm_file = os.path.join(
-        out_dir,
-        "sub-01/func/sub-01_task-mixedgamblestask_run-1_desc-preproc_design.tsv",
-    )
-    dm_df = pd.read_table(dm_file)
-    assert all(c in dm_df.columns for c in confounds_df.columns)
-
 
 @pytest.mark.integration
 @pytest.mark.fmriprep_without_freesurfer_with_main
@@ -353,22 +338,9 @@ def test_fmriprep_without_freesurfer_with_main(data_dir, output_dir, working_dir
     test_name = "test_fmriprep_without_freesurfer"
 
     dataset_dir = download_test_data("fmriprepwithoutfreesurfer", data_dir)
-    temp_dir = os.path.join(output_dir, f"{test_name}_with_main")
-    out_dir = os.path.join(temp_dir, "xcp_d")
+    tmpdir = os.path.join(output_dir, f"{test_name}_with_main")
+    out_dir = os.path.join(tmpdir, "xcp_d")
     work_dir = os.path.join(working_dir, f"{test_name}_with_main")
-    custom_confounds_dir = os.path.join(temp_dir, "custom_confounds")
-    os.makedirs(custom_confounds_dir, exist_ok=True)
-
-    # Create custom confounds folder
-    for run_number in [1, 2]:
-        out_file = f"sub-01_task-mixedgamblestask_run-{run_number}_desc-confounds_timeseries.tsv"
-        out_file = os.path.join(custom_confounds_dir, out_file)
-        confounds_df = pd.DataFrame(
-            columns=["a", "b"],
-            data=np.random.random((16, 2)),
-        )
-        confounds_df.to_csv(out_file, sep="\t", index=False)
-        LOGGER.warning(f"Created custom confounds file at {out_file}.")
 
     parameters = [
         dataset_dir,
@@ -386,7 +358,6 @@ def test_fmriprep_without_freesurfer_with_main(data_dir, output_dir, working_dir
         "--disable-bandpass-filter",
         "--min-time=20",
         "--dummy-scans=1",
-        f"--custom_confounds={custom_confounds_dir}",
         "--abcc-qc",
     ]
 
@@ -400,13 +371,6 @@ def test_fmriprep_without_freesurfer_with_main(data_dir, output_dir, working_dir
     # Run combine-qc too
     combineqc.main([out_dir, "summary"])
 
-    dm_file = os.path.join(
-        out_dir,
-        "sub-01/func/sub-01_task-mixedgamblestask_run-1_desc-preproc_design.tsv",
-    )
-    dm_df = pd.read_table(dm_file)
-    assert all(c in dm_df.columns for c in confounds_df.columns)
-
 
 @pytest.mark.integration
 @pytest.mark.nibabies
diff --git a/xcp_d/tests/test_cli_run.py b/xcp_d/tests/test_cli_run.py
index 8d7c663dd..9019dcc27 100644
--- a/xcp_d/tests/test_cli_run.py
+++ b/xcp_d/tests/test_cli_run.py
@@ -32,7 +32,7 @@ def base_opts():
         "mode": "linc",
         "file_format": "auto",
         "input_type": "auto",
-        "params": "auto",
+        "confounds_config": "auto",
         "high_pass": 0.01,
         "low_pass": 0.1,
         "bandpass_filter": True,
@@ -43,28 +43,27 @@ def base_opts():
         "band_stop_max": None,
         "motion_filter_order": None,
         "process_surfaces": "auto",
-        "fs_license_file": Path(os.environ["FS_LICENSE"]),
         "atlases": ["Glasser"],
-        "custom_confounds": None,
         "dcan_correlation_lengths": None,
         "despike": "auto",
         "abcc_qc": "auto",
         "linc_qc": "auto",
         "combine_runs": "auto",
         "output_type": "auto",
+        "fs_license_file": None,
     }
     opts = FakeOptions(**opts_dict)
     return opts
 
 
 def test_validate_parameters_01(base_opts, base_parser):
-    """Test parser._validate_parameters."""
+    """Test parser._validate_parameters with the pre-set options."""
     opts = deepcopy(base_opts)
     _ = parser._validate_parameters(deepcopy(opts), build_log, parser=base_parser)
 
 
 def test_validate_parameters_02(base_opts, base_parser, caplog):
-    """Test parser._validate_parameters."""
+    """Test parser._validate_parameters with censoring disabled."""
     opts = deepcopy(base_opts)
 
     # Disable censoring
@@ -76,8 +75,8 @@ def test_validate_parameters_02(base_opts, base_parser, caplog):
     assert "Framewise displacement-based scrubbing is disabled." in caplog.text
 
 
-def test_validate_parameters_03(base_opts, base_parser, caplog):
-    """Test parser._validate_parameters."""
+def test_validate_parameters_03(base_opts, base_parser):
+    """Test parser._validate_parameters with the dcan input type."""
     opts = deepcopy(base_opts)
 
     # Set min > max for notch filter
@@ -90,7 +89,7 @@ def test_validate_parameters_03(base_opts, base_parser, caplog):
 
 
 def test_validate_parameters_04(base_opts, base_parser, capsys):
-    """Test parser._validate_parameters."""
+    """Test parser._validate_parameters with nifti outputs and surface processing."""
     opts = deepcopy(base_opts)
 
     # Set min > max for notch filter
@@ -129,22 +128,6 @@ def test_validate_parameters_06(base_opts, base_parser, capsys):
     assert "In order to perform surface normalization" in stderr
 
 
-def test_validate_parameters_07(base_opts, base_parser, caplog, tmp_path_factory):
-    """Test parser._validate_parameters custom confounds + none."""
-    tmpdir = tmp_path_factory.mktemp("test_validate_parameters_07")
-    confounds_path = Path(os.path.join(tmpdir, "confounds.tsv"))
-    confounds_path.touch()  # create the file
-
-    opts = deepcopy(base_opts)
-    opts.params = "none"
-    opts.custom_confounds = confounds_path
-
-    opts = parser._validate_parameters(deepcopy(opts), build_log, parser=base_parser)
-
-    assert opts.params == "custom"
-    assert "Overriding the 'none' value and setting to 'custom'" in caplog.text
-
-
 def test_validate_parameters_motion_filtering(base_opts, base_parser, caplog, capsys):
     """Test parser._validate_parameters."""
     opts = deepcopy(base_opts)
@@ -242,8 +225,11 @@ def test_validate_parameters_bandpass_filter(base_opts, base_parser, caplog, cap
     assert "must be lower than" in capsys.readouterr().err
 
 
-def test_validate_parameters_fs_license(base_opts, base_parser, caplog, capsys, tmp_path_factory):
-    """Ensure parser._validate_parameters returns 2 when fs_license_file doesn't exist."""
+def _test_validate_parameters_fs_license(base_opts, base_parser, caplog, capsys, tmp_path_factory):
+    """Ensure parser._validate_parameters returns 2 when fs_license_file doesn't exist.
+
+    Not run now that the license isn't required.
+    """
     tmpdir = tmp_path_factory.mktemp("test_validate_parameters_fs_license")
 
     opts = deepcopy(base_opts)
@@ -392,6 +378,7 @@ def test_validate_parameters_none_mode(base_opts, base_parser, capsys):
 
     opts.abcc_qc = False
     opts.combine_runs = False
+    opts.confounds_config = "none"
     opts.despike = False
     opts.fd_thresh = 0
     opts.file_format = "nifti"
diff --git a/xcp_d/tests/test_interfaces_censoring.py b/xcp_d/tests/test_interfaces_censoring.py
index b81d9be2b..be103eb84 100644
--- a/xcp_d/tests/test_interfaces_censoring.py
+++ b/xcp_d/tests/test_interfaces_censoring.py
@@ -2,11 +2,14 @@
 
 import json
 import os
+import yaml
 
 import nibabel as nb
 import numpy as np
 import pandas as pd
+import pytest
 
+from xcp_d.data import load as load_data
 from xcp_d.interfaces import censoring
 
 
@@ -28,43 +31,384 @@ def test_generate_confounds(ds001419_data, tmp_path_factory):
 
     # Modify JSON file
     metadata["trans_x"] = {"test": "hello"}
-    confounds_json = os.path.join(tmpdir, "edited_confounds.json")
-    with open(confounds_json, "w") as fo:
-        json.dump(metadata, fo)
 
     # Rename with same convention as initial confounds tsv
     confounds_tsv = os.path.join(tmpdir, "edited_confounds.tsv")
     df.to_csv(confounds_tsv, sep="\t", index=False, header=True)
+    confounds_tsv2 = os.path.join(tmpdir, "edited_confounds_with_signal.tsv")
+    df["signal__fingerpress_condition"] = np.random.random(df.shape[0])
+    df.to_csv(confounds_tsv2, sep="\t", index=False, header=True)
 
-    custom_confounds_file = os.path.join(tmpdir, "custom_confounds.tsv")
-    df2 = pd.DataFrame(columns=["signal__test"], data=np.random.random((df.shape[0], 1)))
-    df2.to_csv(custom_confounds_file, sep="\t", index=False, header=True)
+    confounds_files = {"preproc_confounds": {"file": confounds_tsv, "metadata": metadata}}
 
-    # Run workflow
+    # Test with no motion filtering
+    config = load_data.readable("nuisance/24P.yml")
+    config = yaml.safe_load(config.read_text())
     interface = censoring.GenerateConfounds(
         in_file=in_file,
-        params="24P",
+        confounds_config=config,
         TR=0.8,
-        fd_thresh=0.3,
-        head_radius=50,
-        fmriprep_confounds_file=confounds_tsv,
-        fmriprep_confounds_json=confounds_json,
-        custom_confounds_file=custom_confounds_file,
+        confounds_files=confounds_files,
         motion_filter_type=None,
+        motion_filter_order=0,
+        band_stop_min=0,
+        band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 24  # 24(P)
+    assert "trans_x" in out_df.columns
+
+    # Test with notch motion filtering
+    config = load_data.readable("nuisance/24P.yml")
+    config = yaml.safe_load(config.read_text())
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type="notch",
+        motion_filter_order=4,
+        band_stop_min=12,
+        band_stop_max=20,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 24  # 24(P)
+    assert "trans_x_filtered" in out_df.columns
+
+    # Test with low-pass motion filtering
+    config = load_data.readable("nuisance/24P.yml")
+    config = yaml.safe_load(config.read_text())
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type="lp",
         motion_filter_order=4,
+        band_stop_min=6,
+        band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 24  # 24(P)
+    assert "trans_x_filtered" in out_df.columns
+
+    # Test with regular expressions in confounds_config
+    config = load_data.readable("nuisance/acompcor_gsr.yml")
+    config = yaml.safe_load(config.read_text())
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type=None,
+        motion_filter_order=0,
+        band_stop_min=0,
+        band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 31  # 31 parameters
+
+    # Test with signal regressors
+    config = load_data.readable("nuisance/24P.yml")
+    config = yaml.safe_load(config.read_text())
+    config["confounds"]["preproc_confounds"]["columns"].append("signal__fingerpress_condition")
+    confounds_files = {"preproc_confounds": {"file": confounds_tsv2, "metadata": metadata}}
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type=None,
+        motion_filter_order=0,
+        band_stop_min=0,
+        band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 24  # 24 parameters (doesn't include 25th signal column)
+    assert "signal__fingerpress_condition" not in out_df.columns
+    assert all([col.endswith("_orth") for col in out_df.columns])
+    assert "signal__fingerpress_condition" in results.outputs.confounds_metadata.keys()
+
+    # Test with image-based confounds
+    config = load_data.readable("nuisance/rapidtide+24P.yml")
+    config = yaml.safe_load(config.read_text())
+    confounds_files = {
+        "preproc_confounds": {"file": confounds_tsv, "metadata": metadata},
+        "rapidtide_slfo": {"file": in_file, "metadata": {}},
+    }
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type=None,
+        motion_filter_order=0,
+        band_stop_min=0,
+        band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    results = interface.run(cwd=tmpdir)
+
+    assert os.path.isfile(results.outputs.confounds_tsv)
+    out_confounds_file = results.outputs.confounds_tsv
+    out_df = pd.read_table(out_confounds_file)
+    assert out_df.shape[1] == 25  # 24P + rapidtide (stand-in for the voxel-wise regressor)
+    assert os.path.isfile(results.outputs.confounds_images[0])
+    assert out_df["rapidtide_slfo"].isna().all()
+
+    # Test with image-based confounds and a signal column (will fail)
+    config = load_data.readable("nuisance/rapidtide+24P.yml")
+    config = yaml.safe_load(config.read_text())
+    config["confounds"]["preproc_confounds"]["columns"].append("signal__fingerpress_condition")
+
+    confounds_files = {
+        "preproc_confounds": {"file": confounds_tsv2, "metadata": metadata},
+        "rapidtide_slfo": {"file": in_file, "metadata": {}},
+    }
+    interface = censoring.GenerateConfounds(
+        in_file=in_file,
+        confounds_config=config,
+        TR=0.8,
+        confounds_files=confounds_files,
+        motion_filter_type=None,
+        motion_filter_order=0,
         band_stop_min=0,
         band_stop_max=0,
+        dataset_links={},
+        out_dir=str(tmpdir),
+    )
+    with pytest.raises(NotImplementedError):
+        results = interface.run(cwd=tmpdir)
+
+
+def test_process_motion(ds001419_data, tmp_path_factory):
+    """Test censoring.ProcessMotion."""
+    tmpdir = tmp_path_factory.mktemp("test_process_motion")
+
+    motion_file = ds001419_data["confounds_file"]
+    motion_json = ds001419_data["confounds_json"]
+
+    # Basic test without filtering
+    interface = censoring.ProcessMotion(
+        motion_file=motion_file,
+        motion_json=motion_json,
+        TR=2.0,
+        fd_thresh=0,
+        head_radius=50,
+        motion_filter_type=None,
+        motion_filter_order=None,
+        band_stop_min=None,
+        band_stop_max=None,
+    )
+    results = interface.run(cwd=tmpdir)
+    assert os.path.isfile(results.outputs.motion_file)
+    assert os.path.isfile(results.outputs.temporal_mask)
+
+    # Basic test with censoring, but no filtering
+    interface = censoring.ProcessMotion(
+        motion_file=motion_file,
+        motion_json=motion_json,
+        TR=2.0,
+        fd_thresh=0.2,
+        head_radius=50,
+        motion_filter_type=None,
+        motion_filter_order=None,
+        band_stop_min=None,
+        band_stop_max=None,
     )
     results = interface.run(cwd=tmpdir)
+    assert os.path.isfile(results.outputs.motion_file)
+    assert os.path.isfile(results.outputs.temporal_mask)
 
-    assert os.path.isfile(results.outputs.filtered_confounds_file)
-    assert os.path.isfile(results.outputs.confounds_file)
+    # Basic test with filtering, but not censoring
+    interface = censoring.ProcessMotion(
+        motion_file=motion_file,
+        motion_json=motion_json,
+        TR=2.0,
+        fd_thresh=0,
+        head_radius=50,
+        motion_filter_type="notch",
+        motion_filter_order=4,
+        band_stop_min=12,
+        band_stop_max=20,
+    )
+    results = interface.run(cwd=tmpdir)
+    assert os.path.isfile(results.outputs.motion_file)
+    assert os.path.isfile(results.outputs.temporal_mask)
+
+    # Basic test with filtering and censoring
+    interface = censoring.ProcessMotion(
+        motion_file=motion_file,
+        motion_json=motion_json,
+        TR=2.0,
+        fd_thresh=0.2,
+        head_radius=50,
+        motion_filter_type="notch",
+        motion_filter_order=4,
+        band_stop_min=12,
+        band_stop_max=20,
+    )
+    results = interface.run(cwd=tmpdir)
     assert os.path.isfile(results.outputs.motion_file)
     assert os.path.isfile(results.outputs.temporal_mask)
-    out_confounds_file = results.outputs.confounds_file
-    out_df = pd.read_table(out_confounds_file)
-    assert out_df.shape[1] == 24  # 24(P)
-    assert sum(out_df.columns.str.endswith("_orth")) == 24  # all 24(P)
+
+
+def test_removedummyvolumes_nifti(ds001419_data, tmp_path_factory):
+    """Test RemoveDummyVolumes() for NIFTI input data."""
+    # Define inputs
+    tmpdir = tmp_path_factory.mktemp("test_RemoveDummyVolumes_nifti")
+
+    boldfile = ds001419_data["nifti_file"]
+    confounds_file = ds001419_data["confounds_file"]
+
+    # Find the original number of volumes acc. to nifti & confounds timeseries
+    original_confounds = pd.read_table(confounds_file)
+    original_nvols_nifti = nb.load(boldfile).shape[3]
+
+    # Test a nifti file with 0 volumes to remove
+    remove_nothing = censoring.RemoveDummyVolumes(
+        bold_file=boldfile,
+        confounds_tsv=confounds_file,
+        confounds_images=[boldfile],
+        motion_file=confounds_file,
+        temporal_mask=confounds_file,
+        dummy_scans=0,
+    )
+    results = remove_nothing.run(cwd=tmpdir)
+    undropped_confounds = pd.read_table(results.outputs.confounds_tsv_dropped_TR)
+    # Were the files created?
+    assert os.path.exists(results.outputs.bold_file_dropped_TR)
+    assert os.path.exists(results.outputs.confounds_tsv_dropped_TR)
+    assert os.path.exists(results.outputs.confounds_images_dropped_TR[0])
+    # Have the confounds stayed the same shape?
+    assert undropped_confounds.shape == original_confounds.shape
+    # Has the nifti stayed the same shape?
+    assert (
+        nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3] == original_nvols_nifti
+    )
+
+    # Test a nifti file with 1-10 volumes to remove
+    for n in range(10):
+        remove_n_vols = censoring.RemoveDummyVolumes(
+            bold_file=boldfile,
+            confounds_tsv=confounds_file,
+            confounds_images=[boldfile],
+            motion_file=confounds_file,
+            temporal_mask=confounds_file,
+            dummy_scans=n,
+        )
+        results = remove_n_vols.run(cwd=tmpdir)
+        dropped_confounds = pd.read_table(results.outputs.confounds_tsv_dropped_TR)
+        # Were the files created?
+        assert os.path.exists(results.outputs.bold_file_dropped_TR)
+        assert os.path.exists(results.outputs.confounds_tsv_dropped_TR)
+        assert os.path.exists(results.outputs.confounds_images_dropped_TR[0])
+        # Have the confounds changed correctly?
+        assert dropped_confounds.shape[0] == original_confounds.shape[0] - n
+        # Has the nifti changed correctly?
+        try:
+            assert (
+                nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3]
+                == original_nvols_nifti - n
+            )
+        except Exception as exc:
+            exc = nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[3]
+            print(f"Tests failing at N = {n}.")
+            raise Exception(f"Number of volumes in dropped nifti is {exc}.")
+
+
+def test_removedummyvolumes_cifti(ds001419_data, tmp_path_factory):
+    """Test RemoveDummyVolumes() for CIFTI input data."""
+    # Define inputs
+    tmpdir = tmp_path_factory.mktemp("test_RemoveDummyVolumes_cifti")
+
+    boldfile = ds001419_data["cifti_file"]
+    confounds_file = ds001419_data["confounds_file"]
+
+    # Find the original number of volumes acc. to cifti & confounds timeseries
+    original_confounds = pd.read_table(confounds_file)
+    original_nvols_cifti = nb.load(boldfile).shape[0]
+
+    # Test a cifti file with 0 volumes to remove
+    remove_nothing = censoring.RemoveDummyVolumes(
+        bold_file=boldfile,
+        confounds_tsv=confounds_file,
+        confounds_images=[boldfile],
+        motion_file=confounds_file,
+        temporal_mask=confounds_file,
+        dummy_scans=0,
+    )
+    results = remove_nothing.run(cwd=tmpdir)
+    undropped_confounds = pd.read_table(results.outputs.confounds_tsv_dropped_TR)
+    # Were the files created?
+    assert os.path.exists(results.outputs.bold_file_dropped_TR)
+    assert os.path.exists(results.outputs.confounds_tsv_dropped_TR)
+    # Have the confounds stayed the same shape?
+    assert undropped_confounds.shape == original_confounds.shape
+    # Has the cifti stayed the same shape?
+    assert (
+        nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0] == original_nvols_cifti
+    )
+
+    # Test a cifti file with 1-10 volumes to remove
+    for n in range(10):
+        remove_n_vols = censoring.RemoveDummyVolumes(
+            bold_file=boldfile,
+            confounds_tsv=confounds_file,
+            confounds_images=[boldfile],
+            motion_file=confounds_file,
+            temporal_mask=confounds_file,
+            dummy_scans=n,
+        )
+
+        results = remove_n_vols.run(cwd=tmpdir)
+        dropped_confounds = pd.read_table(results.outputs.confounds_tsv_dropped_TR)
+        # Were the files created?
+        assert os.path.exists(results.outputs.bold_file_dropped_TR)
+        assert os.path.exists(results.outputs.confounds_tsv_dropped_TR)
+        # Have the confounds changed correctly?
+        assert dropped_confounds.shape[0] == original_confounds.shape[0] - n
+        # Has the cifti changed correctly?
+        try:
+            assert (
+                nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0]
+                == original_nvols_cifti - n
+            )
+        except Exception as exc:
+            exc = nb.load(results.outputs.bold_file_dropped_TR).get_fdata().shape[0]
+            print(f"Tests failing at N = {n}.")
+            raise Exception(f"Number of volumes in dropped cifti is {exc}.")
 
 
 def test_random_censor(tmp_path_factory):
@@ -138,9 +482,10 @@ def test_censor(ds001419_data, tmp_path_factory):
     interface = censoring.Censor(
         in_file=nifti_file,
         temporal_mask=temporal_mask,
+        column="framewise_displacement",
     )
     results = interface.run(cwd=tmpdir)
-    out_file = results.outputs.censored_denoised_bold
+    out_file = results.outputs.out_file
     assert os.path.isfile(out_file)
     out_img = nb.load(out_file)
     assert out_img.shape[3] == n_volumes
@@ -149,35 +494,67 @@ def test_censor(ds001419_data, tmp_path_factory):
     interface = censoring.Censor(
         in_file=cifti_file,
         temporal_mask=temporal_mask,
+        column="framewise_displacement",
     )
     results = interface.run(cwd=tmpdir)
-    out_file = results.outputs.censored_denoised_bold
+    out_file = results.outputs.out_file
     assert os.path.isfile(out_file)
     out_img = nb.load(out_file)
     assert out_img.shape[0] == n_volumes
 
-    # Test with a NIfTI file, with some censored volumes
+    # Create a temporal mask with some censored volumes
     n_censored_volumes = 10
     n_retained_volumes = n_volumes - n_censored_volumes
     censoring_df.loc[range(10), "framewise_displacement"] = 1
+    # Add random censor column
+    censoring_df["random_censor"] = 0
+    censoring_df.loc[20:29, "random_censor"] = 1
     censoring_df.to_csv(temporal_mask, sep="\t", index=False)
+
+    # Test with a NIfTI file, with some censored volumes
     interface = censoring.Censor(
         in_file=nifti_file,
         temporal_mask=temporal_mask,
+        column="framewise_displacement",
     )
     results = interface.run(cwd=tmpdir)
-    out_file = results.outputs.censored_denoised_bold
+    out_file = results.outputs.out_file
     assert os.path.isfile(out_file)
     out_img = nb.load(out_file)
     assert out_img.shape[3] == n_retained_volumes
 
+    # Test with additional censoring column
+    interface2 = censoring.Censor(
+        in_file=results.outputs.out_file,
+        temporal_mask=temporal_mask,
+        column="random_censor",
+    )
+    results2 = interface2.run(cwd=tmpdir)
+    out_file2 = results2.outputs.out_file
+    assert os.path.isfile(out_file2)
+    out_img2 = nb.load(out_file2)
+    assert out_img2.shape[3] == (n_retained_volumes - 10)
+
     # Test with a CIFTI file, with some censored volumes
     interface = censoring.Censor(
         in_file=cifti_file,
         temporal_mask=temporal_mask,
+        column="framewise_displacement",
     )
     results = interface.run(cwd=tmpdir)
-    out_file = results.outputs.censored_denoised_bold
+    out_file = results.outputs.out_file
     assert os.path.isfile(out_file)
     out_img = nb.load(out_file)
     assert out_img.shape[0] == n_retained_volumes
+
+    # Test with additional censoring column
+    interface2 = censoring.Censor(
+        in_file=results.outputs.out_file,
+        temporal_mask=temporal_mask,
+        column="random_censor",
+    )
+    results2 = interface2.run(cwd=tmpdir)
+    out_file2 = results2.outputs.out_file
+    assert os.path.isfile(out_file2)
+    out_img2 = nb.load(out_file2)
+    assert out_img2.shape[0] == (n_retained_volumes - 10)
diff --git a/xcp_d/tests/test_interfaces_concatenation.py b/xcp_d/tests/test_interfaces_concatenation.py
index 4f2dbe1fa..6068ae4e0 100644
--- a/xcp_d/tests/test_interfaces_concatenation.py
+++ b/xcp_d/tests/test_interfaces_concatenation.py
@@ -13,7 +13,7 @@ def test_cleannamesource(datasets):
         datasets["ds001419"],
         "sub-01",
         "func",
-        "sub-01_task-imagery_run-02_space-MNI152NLin2009cAsym_res-2_desc-preproc_bold.nii.gz",
+        "sub-01_task-imagery_run-02_space-MNI152NLin6Asym_res-2_desc-preproc_bold.nii.gz",
     )
 
     interface = concatenation.CleanNameSource(
@@ -26,7 +26,7 @@ def test_cleannamesource(datasets):
         datasets["ds001419"],
         "sub-01",
         "func",
-        "sub-01_task-imagery_space-MNI152NLin2009cAsym_res-2_desc-preproc_bold.nii.gz",
+        "sub-01_task-imagery_space-MNI152NLin6Asym_res-2_desc-preproc_bold.nii.gz",
     )
     assert name_source == expected_name_source
 
@@ -40,8 +40,7 @@ def test_filteroutfailedruns(ds001419_data):
     n_runs = len(denoised_bold)
     n_good_runs = 2
     preprocessed_bold = [nifti_file] * n_runs
-    fmriprep_confounds_file = [tsv_file] * n_runs
-    filtered_motion = [tsv_file] * n_runs
+    motion_file = [tsv_file] * n_runs
     temporal_mask = [nifti_file] * n_runs
     denoised_interpolated_bold = [nifti_file] * n_runs
     censored_denoised_bold = [nifti_file] * n_runs
@@ -59,8 +58,7 @@ def test_filteroutfailedruns(ds001419_data):
         denoised_bold=denoised_bold,
         censored_denoised_bold=censored_denoised_bold,
         preprocessed_bold=preprocessed_bold,
-        fmriprep_confounds_file=fmriprep_confounds_file,
-        filtered_motion=filtered_motion,
+        motion_file=motion_file,
         temporal_mask=temporal_mask,
         denoised_interpolated_bold=denoised_interpolated_bold,
         smoothed_denoised_bold=smoothed_denoised_bold,
@@ -74,8 +72,7 @@ def test_filteroutfailedruns(ds001419_data):
     assert len(out.denoised_bold) == n_good_runs
     assert len(out.censored_denoised_bold) == n_good_runs
     assert len(out.preprocessed_bold) == n_good_runs
-    assert len(out.fmriprep_confounds_file) == n_good_runs
-    assert len(out.filtered_motion) == n_good_runs
+    assert len(out.motion_file) == n_good_runs
     assert len(out.temporal_mask) == n_good_runs
     assert len(out.denoised_interpolated_bold) == n_good_runs
     assert len(out.smoothed_denoised_bold) == n_good_runs
@@ -98,8 +95,7 @@ def test_concatenateinputs(ds001419_data, tmp_path_factory):
     denoised_bold = [nifti_file] * n_runs
     censored_denoised_bold = [nifti_file] * n_runs
     preprocessed_bold = [nifti_file] * n_runs
-    fmriprep_confounds_file = [tsv_file] * n_runs
-    filtered_motion = [tsv_file] * n_runs
+    motion_file = [tsv_file] * n_runs
     temporal_mask = [tsv_file] * n_runs
     denoised_interpolated_bold = [nifti_file] * n_runs
 
@@ -111,14 +107,13 @@ def test_concatenateinputs(ds001419_data, tmp_path_factory):
     timeseries_ciftis = [[cifti_file] * n_atlases] * n_runs
 
     interface = concatenation.ConcatenateInputs(
-        denoised_bold=denoised_bold,
-        censored_denoised_bold=censored_denoised_bold,
         preprocessed_bold=preprocessed_bold,
+        denoised_bold=denoised_bold,
         denoised_interpolated_bold=denoised_interpolated_bold,
+        censored_denoised_bold=censored_denoised_bold,
         smoothed_denoised_bold=smoothed_denoised_bold,
         timeseries_ciftis=timeseries_ciftis,
-        fmriprep_confounds_file=fmriprep_confounds_file,
-        filtered_motion=filtered_motion,
+        motion_file=motion_file,
         temporal_mask=temporal_mask,
         timeseries=timeseries,
     )
@@ -131,8 +126,7 @@ def test_concatenateinputs(ds001419_data, tmp_path_factory):
     assert not isdefined(out.smoothed_denoised_bold)
     assert len(out.timeseries_ciftis) == n_atlases
     assert all(os.path.isfile(f) for f in out.timeseries_ciftis)
-    assert os.path.isfile(out.fmriprep_confounds_file)
-    assert os.path.isfile(out.filtered_motion)
+    assert os.path.isfile(out.motion_file)
     assert os.path.isfile(out.temporal_mask)
     assert len(out.timeseries) == n_atlases
     assert all(os.path.isfile(f) for f in out.timeseries)
diff --git a/xcp_d/tests/test_interfaces_nilearn.py b/xcp_d/tests/test_interfaces_nilearn.py
index c5ee9dc89..9a4745146 100644
--- a/xcp_d/tests/test_interfaces_nilearn.py
+++ b/xcp_d/tests/test_interfaces_nilearn.py
@@ -69,12 +69,24 @@ def test_nilearn_binarymath(ds001419_data, tmp_path_factory):
     assert np.min(out_data) == 0
 
 
-def test_nilearn_resampletoimage(ds001419_data, tmp_path_factory):
+def test_nilearn_resampletoimage(datasets, tmp_path_factory):
     """Test xcp_d.interfaces.nilearn.ResampleToImage."""
-    tmpdir = tmp_path_factory.mktemp("test_nilearn_meanimage")
-
-    source_file = ds001419_data["boldref_t1w"]
-    target_file = ds001419_data["t1w"]
+    tmpdir = tmp_path_factory.mktemp("test_nilearn_resampletoimage")
+
+    source_file = os.path.join(
+        datasets["nibabies"],
+        "sub-01",
+        "ses-1mo",
+        "func",
+        "sub-01_ses-1mo_task-rest_acq-PA_run-001_space-MNIInfant_cohort-1_boldref.nii.gz",
+    )
+    target_file = os.path.join(
+        datasets["nibabies"],
+        "sub-01",
+        "ses-1mo",
+        "anat",
+        "sub-01_ses-1mo_run-001_space-MNIInfant_cohort-1_desc-preproc_T1w.nii.gz",
+    )
     target_img = nb.load(target_file)
     source_img = nb.load(source_file)
     assert not np.array_equal(target_img.header.get_zooms(), source_img.header.get_zooms())
@@ -116,7 +128,7 @@ def test_nilearn_denoisenifti(ds001419_data, tmp_path_factory):
 
     interface = nilearn.DenoiseNifti(
         preprocessed_bold=preprocessed_bold,
-        confounds_file=reduced_confounds_file,
+        confounds_tsv=reduced_confounds_file,
         temporal_mask=temporal_mask,
         mask=mask,
         TR=2,
@@ -154,7 +166,7 @@ def test_nilearn_denoisecifti(ds001419_data, tmp_path_factory):
 
     interface = nilearn.DenoiseCifti(
         preprocessed_bold=preprocessed_bold,
-        confounds_file=reduced_confounds_file,
+        confounds_tsv=reduced_confounds_file,
         temporal_mask=temporal_mask,
         TR=2,
         bandpass_filter=True,
diff --git a/xcp_d/tests/test_utils_bids.py b/xcp_d/tests/test_utils_bids.py
index 1f5e78e50..8a2c80efc 100644
--- a/xcp_d/tests/test_utils_bids.py
+++ b/xcp_d/tests/test_utils_bids.py
@@ -58,12 +58,12 @@ def test_collect_data_ds001419(datasets):
         file_format="nifti",
     )
 
-    assert len(subj_data["bold"]) == 5
-    assert "space-MNI152NLin2009cAsym" in subj_data["bold"][0]
+    assert len(subj_data["bold"]) == 4
+    assert "space-MNI152NLin6Asym" in subj_data["bold"][0]
     assert os.path.basename(subj_data["t1w"]) == "sub-01_desc-preproc_T1w.nii.gz"
     assert "space-" not in subj_data["t1w"]
-    assert "to-MNI152NLin2009cAsym" in subj_data["anat_to_template_xfm"]
-    assert "from-MNI152NLin2009cAsym" in subj_data["template_to_anat_xfm"]
+    assert "to-MNI152NLin6Asym" in subj_data["anat_to_template_xfm"]
+    assert "from-MNI152NLin6Asym" in subj_data["template_to_anat_xfm"]
 
     # CIFTI workflow
     subj_data = xbids.collect_data(
@@ -78,8 +78,8 @@ def test_collect_data_ds001419(datasets):
     assert "space-fsLR" in subj_data["bold"][0]
     assert "space-" not in subj_data["t1w"]
     assert os.path.basename(subj_data["t1w"]) == "sub-01_desc-preproc_T1w.nii.gz"
-    assert "to-MNI152NLin2009cAsym" in subj_data["anat_to_template_xfm"]
-    assert "from-MNI152NLin2009cAsym" in subj_data["template_to_anat_xfm"]
+    assert "to-MNI152NLin6Asym" in subj_data["anat_to_template_xfm"]
+    assert "from-MNI152NLin6Asym" in subj_data["template_to_anat_xfm"]
 
 
 def test_collect_data_nibabies(datasets):
@@ -264,7 +264,6 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
             tmpdir,
             tmpdir,
             atlases=None,
-            custom_confounds_folder=None,
             dataset_links={},
         )
     assert not os.path.isfile(dset_description)
@@ -275,8 +274,7 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
         fmri_dir,
         tmpdir,
         atlases=["Gordon"],
-        custom_confounds_folder="/fake/path4",
-        dataset_links={"preprocessed": "/fake/path1"},
+        dataset_links={"preprocessed": "/fake/path1", "confounds": "/fake/path4"},
     )
     assert os.path.isfile(dset_description)
 
@@ -284,17 +282,16 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
     with open(dset_description, "r") as fo:
         desc = json.load(fo)
 
-    assert "'preprocessed' is already a dataset link" not in caplog.text
-    assert "'custom_confounds' is already a dataset link" not in caplog.text
+    assert "DatasetLink 'preprocessed' does not match" not in caplog.text
+    assert "DatasetLink 'confounds' does not match" not in caplog.text
     xbids.write_derivative_description(
         tmpdir,
         tmpdir,
         atlases=["Gordon"],
-        custom_confounds_folder="/fake/path5",
-        dataset_links={"preprocessed": "/fake/path2"},
+        dataset_links={"preprocessed": "/fake/path2", "confounds": "/fake/path5"},
     )
-    assert "'preprocessed' is already a dataset link" in caplog.text
-    assert "'custom_confounds' is already a dataset link" in caplog.text
+    assert "DatasetLink 'preprocessed' does not match" in caplog.text
+    assert "DatasetLink 'confounds' does not match" in caplog.text
 
     # Now change the version and re-run the function.
     desc["GeneratedBy"][0]["Version"] = "0.0.1"
@@ -306,7 +303,6 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
         fmri_dir,
         tmpdir,
         atlases=None,
-        custom_confounds_folder=None,
         dataset_links={},
     )
     assert "Previous output generated by version" in caplog.text
@@ -321,7 +317,6 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
         tmpdir,
         tmpdir,
         atlases=None,
-        custom_confounds_folder=None,
         dataset_links={},
     )
     assert "DatasetType key not in" in caplog.text
@@ -336,7 +331,6 @@ def test_write_derivative_description(datasets, tmp_path_factory, caplog):
             tmpdir,
             tmpdir,
             atlases=None,
-            custom_confounds_folder=None,
             dataset_links={},
         )
 
@@ -548,13 +542,3 @@ def test_make_preproc_uri():
 
     xbids._make_preproc_uri([out_file], fmri_dir="/path/to/dset")
     assert uri == ["bids:preprocessed:sub-01/func/sub-01_task-rest_bold.nii.gz"]
-
-
-def test_make_custom_uri():
-    """Test _make_custom_uri."""
-    out_file = "/path/to/dset/sub-01_task-rest_bold.nii.gz"
-    uri = xbids._make_custom_uri(out_file)
-    assert uri == ["bids:custom_confounds:sub-01_task-rest_bold.nii.gz"]
-
-    xbids._make_custom_uri([out_file])
-    assert uri == ["bids:custom_confounds:sub-01_task-rest_bold.nii.gz"]
diff --git a/xcp_d/tests/test_utils_boilerplate.py b/xcp_d/tests/test_utils_boilerplate.py
index 8f8f413dd..dbe7912c5 100644
--- a/xcp_d/tests/test_utils_boilerplate.py
+++ b/xcp_d/tests/test_utils_boilerplate.py
@@ -1,12 +1,9 @@
 """Test confounds handling."""
 
-import os
-
-import numpy as np
-import pandas as pd
 import pytest
-from nilearn.glm.first_level import make_first_level_design_matrix
+import yaml
 
+from xcp_d.data import load as load_data
 from xcp_d.utils import boilerplate
 
 
@@ -17,18 +14,15 @@ def test_describe_motion_parameters():
         motion_filter_order=None,
         band_stop_min=None,
         band_stop_max=None,
-        head_radius=50,
         TR=0.8,
     )
     assert "filtered to remove signals" not in desc
-    assert "Framewise displacement was calculated" in desc
 
     desc = boilerplate.describe_motion_parameters(
         motion_filter_type="notch",
         motion_filter_order=1,
         band_stop_min=12,
         band_stop_max=20,
-        head_radius=50,
         TR=0.8,
     )
     assert "band-stop filtered to remove signals" in desc
@@ -39,7 +33,6 @@ def test_describe_motion_parameters():
         motion_filter_order=1,
         band_stop_min=12,
         band_stop_max=20,
-        head_radius=50,
         TR=3,
     )
     assert "band-stop filtered to remove signals" in desc
@@ -50,7 +43,6 @@ def test_describe_motion_parameters():
         motion_filter_order=1,
         band_stop_min=12,
         band_stop_max=20,
-        head_radius=50,
         TR=0.8,
     )
     assert "low-pass filtered" in desc
@@ -61,7 +53,6 @@ def test_describe_motion_parameters():
         motion_filter_order=1,
         band_stop_min=12,
         band_stop_max=20,
-        head_radius=50,
         TR=3,
     )
     assert "low-pass filtered" in desc
@@ -73,60 +64,64 @@ def test_describe_censoring():
     motion_filter_type = "notch"
     fd_thresh = 0.2
     exact_scans = []
-    desc = boilerplate.describe_censoring(motion_filter_type, fd_thresh, exact_scans)
+    desc = boilerplate.describe_censoring(
+        motion_filter_type=motion_filter_type,
+        head_radius=50,
+        fd_thresh=fd_thresh,
+        exact_scans=exact_scans,
+    )
     assert "Volumes with filtered framewise displacement" in desc
 
     motion_filter_type = None
     fd_thresh = 0.2
     exact_scans = []
-    desc = boilerplate.describe_censoring(motion_filter_type, fd_thresh, exact_scans)
+    desc = boilerplate.describe_censoring(
+        motion_filter_type=motion_filter_type,
+        head_radius=50,
+        fd_thresh=fd_thresh,
+        exact_scans=exact_scans,
+    )
     assert "Volumes with framewise displacement" in desc
 
     motion_filter_type = None
     fd_thresh = 0.2
     exact_scans = [100, 200, 300]
-    desc = boilerplate.describe_censoring(motion_filter_type, fd_thresh, exact_scans)
+    desc = boilerplate.describe_censoring(
+        motion_filter_type=motion_filter_type,
+        head_radius=50,
+        fd_thresh=fd_thresh,
+        exact_scans=exact_scans,
+    )
     assert "Volumes with framewise displacement" in desc
     assert "limited to 100, 200, and 300 volumes" in desc
 
     motion_filter_type = None
     fd_thresh = 0
     exact_scans = [100, 200, 300]
-    desc = boilerplate.describe_censoring(motion_filter_type, fd_thresh, exact_scans)
+    desc = boilerplate.describe_censoring(
+        motion_filter_type=motion_filter_type,
+        head_radius=50,
+        fd_thresh=fd_thresh,
+        exact_scans=exact_scans,
+    )
     assert "Volumes were randomly selected for censoring" in desc
     assert "limited to 100, 200, and 300 volumes" in desc
 
     motion_filter_type = "notch"
     fd_thresh = 0
     exact_scans = [100, 200, 300]
-    desc = boilerplate.describe_censoring(motion_filter_type, fd_thresh, exact_scans)
+    desc = boilerplate.describe_censoring(
+        motion_filter_type=motion_filter_type,
+        head_radius=50,
+        fd_thresh=fd_thresh,
+        exact_scans=exact_scans,
+    )
     assert "Volumes were randomly selected for censoring" in desc
     assert "limited to 100, 200, and 300 volumes" in desc
 
 
 def test_describe_regression(tmp_path_factory):
     """Test boilerplate.describe_regression."""
-    tempdir = tmp_path_factory.mktemp("test_describe_regression")
-    N_VOLUMES, TR = 60, 2.5
-
-    events_df = pd.DataFrame(
-        {
-            "onset": [10, 30, 50],
-            "duration": [5, 10, 5],
-            "trial_type": (["signal__condition01"] * 2) + (["condition02"] * 1),
-        },
-    )
-    custom_confounds = make_first_level_design_matrix(
-        np.arange(N_VOLUMES) * TR,
-        events_df,
-        drift_model=None,
-        hrf_model="spm",
-        high_pass=None,
-    )
-    custom_confounds = custom_confounds.drop(columns="constant")
-    custom_confounds_file = os.path.join(tempdir, "file.tsv")
-    custom_confounds.to_csv(custom_confounds_file, sep="\t", index=False)
-
     _check_describe_regression_result("24P", "24 nuisance regressors were selected")
     _check_describe_regression_result("27P", "27 nuisance regressors were selected")
     _check_describe_regression_result("36P", "36 nuisance regressors were selected")
@@ -134,40 +129,49 @@ def test_describe_regression(tmp_path_factory):
     _check_describe_regression_result("acompcor_gsr", "The top 5 aCompCor principal components")
     _check_describe_regression_result("aroma", "AROMA motion-labeled components")
     _check_describe_regression_result("aroma_gsr", "AROMA motion-labeled components")
-    _check_describe_regression_result("custom", "A custom set of regressors was used")
-    _check_describe_regression_result("none", "No nuisance regression was performed")
+    _check_describe_regression_result(None, "No nuisance regression was performed")
+
+    # Try with motion filter
+    config = load_data.readable("nuisance/24P.yml")
+    config = yaml.safe_load(config.read_text())
+
+    result = boilerplate.describe_regression(
+        confounds_config=config,
+        motion_filter_type="lp",
+        motion_filter_order=4,
+        band_stop_min=6,
+        band_stop_max=0,
+        TR=0.8,
+        fd_thresh=0,
+    )
+    assert isinstance(result, str)
 
-    with pytest.raises(ValueError, match="Unrecognized parameter string"):
+    # Fails. Need to replace with a better test.
+    with pytest.raises(TypeError, match="string indices must be integers"):
         boilerplate.describe_regression(
-            params="test",
-            custom_confounds_file=None,
+            confounds_config="test",
             motion_filter_type=None,
+            motion_filter_order=0,
+            band_stop_min=0,
+            band_stop_max=0,
+            TR=0.8,
+            fd_thresh=0,
         )
 
-    # Test with custom confounds file
-    desc = boilerplate.describe_regression(
-        params="24P",
-        custom_confounds_file=custom_confounds_file,
-        motion_filter_type=None,
-    )
-    assert isinstance(desc, str)
-    assert "custom confounds were also included" in desc
-    assert "24 nuisance regressors were selected" in desc
-
-    desc = boilerplate.describe_regression(
-        params="custom",
-        custom_confounds_file=custom_confounds_file,
-        motion_filter_type=None,
-    )
-    assert isinstance(desc, str)
-    assert "A custom set of regressors was used" in desc
 
+def _check_describe_regression_result(config, match):
+    if isinstance(config, str):
+        config = load_data.readable(f"nuisance/{config}.yml")
+        config = yaml.safe_load(config.read_text())
 
-def _check_describe_regression_result(params, match):
     result = boilerplate.describe_regression(
-        params=params,
-        custom_confounds_file=None,
+        confounds_config=config,
         motion_filter_type=None,
+        motion_filter_order=0,
+        band_stop_min=0,
+        band_stop_max=0,
+        TR=0.8,
+        fd_thresh=0,
     )
     assert isinstance(result, str)
     assert match in result
diff --git a/xcp_d/tests/test_utils_confounds.py b/xcp_d/tests/test_utils_confounds.py
index 5f5d934ee..5399ce414 100644
--- a/xcp_d/tests/test_utils_confounds.py
+++ b/xcp_d/tests/test_utils_confounds.py
@@ -1,166 +1,14 @@
 """Tests for xcp_d.utils.confounds."""
 
-import os
 import re
 
 import numpy as np
-import pandas as pd
 import pytest
-from nilearn.glm.first_level import make_first_level_design_matrix
 from scipy import signal
 
 from xcp_d.utils import confounds
 
 
-def test_custom_confounds(ds001419_data, tmp_path_factory):
-    """Ensure that custom confounds can be loaded without issue."""
-    tempdir = tmp_path_factory.mktemp("test_custom_confounds")
-    bold_file = ds001419_data["nifti_file"]
-    confounds_file = ds001419_data["confounds_file"]
-    confounds_json = ds001419_data["confounds_json"]
-
-    N_VOLUMES = 60
-    TR = 2.5
-
-    frame_times = np.arange(N_VOLUMES) * TR
-    events_df = pd.DataFrame(
-        {
-            "onset": [10, 30, 50],
-            "duration": [5, 10, 5],
-            "trial_type": (["condition01"] * 2) + (["condition02"] * 1),
-        },
-    )
-    custom_confounds = make_first_level_design_matrix(
-        frame_times,
-        events_df,
-        drift_model=None,
-        hrf_model="spm",
-        high_pass=None,
-    )
-    # The design matrix will include a constant column, which we should drop
-    custom_confounds = custom_confounds.drop(columns="constant")
-
-    # Save to file
-    custom_confounds_file = os.path.join(
-        tempdir,
-        "sub-01_task-rest_desc-confounds_timeseries.tsv",
-    )
-    custom_confounds.to_csv(custom_confounds_file, sep="\t", index=False)
-
-    combined_confounds, _ = confounds.load_confound_matrix(
-        params="24P",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-        custom_confounds=custom_confounds_file,
-    )
-    # We expect n params + 2 (one for each condition in custom confounds)
-    assert combined_confounds.shape == (N_VOLUMES, 26)
-    assert "condition01" in combined_confounds.columns
-    assert "condition02" in combined_confounds.columns
-
-    custom_confounds, _ = confounds.load_confound_matrix(
-        params="custom",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-        custom_confounds=custom_confounds_file,
-    )
-    # We expect 2 (one for each condition in custom confounds)
-    assert combined_confounds.shape == (N_VOLUMES, 26)
-    assert "condition01" in combined_confounds.columns
-    assert "condition02" in combined_confounds.columns
-
-
-def test_load_confounds(ds001419_data):
-    """Ensure that xcp_d loads the right confounds."""
-    bold_file = ds001419_data["nifti_file"]
-    confounds_file = ds001419_data["confounds_file"]
-    confounds_json = ds001419_data["confounds_json"]
-
-    N_VOLUMES = 60
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="24P",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 24)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="27P",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 27)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="36P",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 36)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="acompcor",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 28)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="acompcor_gsr",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 29)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="aroma",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 48)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="aroma_gsr",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert confounds_df.shape == (N_VOLUMES, 49)
-
-    confounds_df, _ = confounds.load_confound_matrix(
-        params="none",
-        img_file=bold_file,
-        confounds_file=confounds_file,
-        confounds_json_file=confounds_json,
-    )
-    assert not confounds_df
-
-    with pytest.raises(ValueError, match="Unrecognized parameter string"):
-        confounds.load_confound_matrix(
-            params="test",
-            img_file=bold_file,
-            confounds_file=confounds_file,
-            confounds_json_file=confounds_json,
-        )
-
-    with pytest.raises(ValueError):
-        confounds.load_confound_matrix(
-            params="custom",
-            img_file=bold_file,
-            confounds_file=confounds_file,
-            confounds_json_file=confounds_json,
-        )
-
-
 def test_modify_motion_filter():
     """Run a simple test of the motion filter modification function."""
     band_stop_min = 6
@@ -252,7 +100,7 @@ def test_motion_filtering_lp():
 
     # Confirm the LP filter runs with reasonable parameters
     raw_data = raw_data[:, None]  # add singleton row dimension
-    lowpass_data_test = confounds.motion_regression_filter(
+    lowpass_data_test = confounds.filter_motion(
         raw_data,
         TR=TR,
         motion_filter_type="lp",
@@ -266,7 +114,7 @@ def test_motion_filtering_lp():
 
     # Using a filter type other than notch or lp should raise an exception.
     with pytest.raises(ValueError, match="Motion filter type 'fail' not supported."):
-        confounds.motion_regression_filter(
+        confounds.filter_motion(
             raw_data,
             TR=TR,
             motion_filter_type="fail",
@@ -300,7 +148,7 @@ def test_motion_filtering_notch():
 
     # Repeat for notch filter
     raw_data = raw_data[:, None]  # add singleton row dimension
-    notch_data_test = confounds.motion_regression_filter(
+    notch_data_test = confounds.filter_motion(
         raw_data,
         TR=TR,  # 1.25 Hz
         motion_filter_type="notch",
diff --git a/xcp_d/tests/test_utils_execsummary.py b/xcp_d/tests/test_utils_execsummary.py
index e09d1407f..65408e115 100644
--- a/xcp_d/tests/test_utils_execsummary.py
+++ b/xcp_d/tests/test_utils_execsummary.py
@@ -76,7 +76,7 @@ def test_get_n_frames(ds001419_data):
     """Test get_n_frames."""
     anat_file = ds001419_data["brain_mask_file"]
     frame_numbers = execsummary.get_n_frames(anat_file)
-    assert len(frame_numbers) == 194
+    assert len(frame_numbers) == 183
 
 
 def test_get_png_image_names():
diff --git a/xcp_d/tests/test_utils_plotting.py b/xcp_d/tests/test_utils_plotting.py
index 037ea54d4..e70a8bbe3 100644
--- a/xcp_d/tests/test_utils_plotting.py
+++ b/xcp_d/tests/test_utils_plotting.py
@@ -16,11 +16,11 @@ def test_plot_fmri_es(ds001419_data, tmp_path_factory):
     denoised_interpolated_bold = ds001419_data["cifti_file"]
 
     # Using unfiltered FD instead of calculating filtered version.
-    filtered_motion = ds001419_data["confounds_file"]
+    motion_file = ds001419_data["confounds_file"]
     preprocessed_figure = os.path.join(tmpdir, "unprocessed.svg")
     denoised_figure = os.path.join(tmpdir, "processed.svg")
     t_r = 2
-    n_volumes = pd.read_table(filtered_motion).shape[0]
+    n_volumes = pd.read_table(motion_file).shape[0]
     tmask_arr = np.zeros(n_volumes, dtype=bool)
     tmask_arr[:10] = True  # flag first 10 volumes as bad
     tmask_arr = tmask_arr.astype(int)
@@ -32,7 +32,7 @@ def test_plot_fmri_es(ds001419_data, tmp_path_factory):
     out_file1, out_file2 = plotting.plot_fmri_es(
         preprocessed_bold=preprocessed_bold,
         denoised_interpolated_bold=denoised_interpolated_bold,
-        filtered_motion=filtered_motion,
+        motion_file=motion_file,
         preprocessed_figure=preprocessed_figure,
         denoised_figure=denoised_figure,
         TR=t_r,
@@ -49,7 +49,7 @@ def test_plot_fmri_es(ds001419_data, tmp_path_factory):
     out_file1, out_file2 = plotting.plot_fmri_es(
         preprocessed_bold=preprocessed_bold,
         denoised_interpolated_bold=denoised_interpolated_bold,
-        filtered_motion=filtered_motion,
+        motion_file=motion_file,
         preprocessed_figure=preprocessed_figure,
         denoised_figure=denoised_figure,
         TR=t_r,
diff --git a/xcp_d/tests/test_utils_utils.py b/xcp_d/tests/test_utils_utils.py
index 8b1e8c152..5d85a3897 100644
--- a/xcp_d/tests/test_utils_utils.py
+++ b/xcp_d/tests/test_utils_utils.py
@@ -13,7 +13,7 @@ def test_estimate_brain_radius(ds001419_data):
     bold_mask = ds001419_data["brain_mask_file"]
 
     radius = utils.estimate_brain_radius(bold_mask, head_radius="auto")
-    assert radius == 78.12350298308195
+    assert radius == 77.39268749395897
 
     radius = utils.estimate_brain_radius(bold_mask, head_radius=50)
     assert radius == 50
@@ -339,32 +339,32 @@ def test_list_to_str():
 
 def test_get_bold2std_and_t1w_xfms(ds001419_data):
     """Test get_bold2std_and_t1w_xfms."""
-    bold_file_nlin2009c = ds001419_data["nifti_file"]
-    nlin2009c_to_anat_xfm = ds001419_data["template_to_anat_xfm"]
+    bold_file_nlin6asym = ds001419_data["nifti_file"]
+    nlin6asym_to_anat_xfm = ds001419_data["template_to_anat_xfm"]
 
-    # MNI152NLin2009cAsym --> MNI152NLin2009cAsym/T1w
+    # MNI152NLin6Asym --> MNI152NLin2009cAsym/T1w
     (
         xforms_to_mni,
         xforms_to_mni_invert,
         xforms_to_t1w,
         xforms_to_t1w_invert,
     ) = utils.get_bold2std_and_t1w_xfms(
-        bold_file_nlin2009c,
-        nlin2009c_to_anat_xfm,
+        bold_file_nlin6asym,
+        nlin6asym_to_anat_xfm,
     )
     assert len(xforms_to_mni) == 1
     assert len(xforms_to_mni_invert) == 1
     assert len(xforms_to_t1w) == 1
     assert len(xforms_to_t1w_invert) == 1
 
-    # MNI152NLin6Asym --> MNI152NLin2009cAsym/T1w
-    bold_file_nlin6asym = bold_file_nlin2009c.replace(
-        "space-MNI152NLin2009cAsym_",
+    # MNI152NLin2009cAsym --> MNI152NLin2009cAsym/T1w
+    bold_file_nlin2009c = bold_file_nlin6asym.replace(
         "space-MNI152NLin6Asym_",
+        "space-MNI152NLin2009cAsym_",
     )
-    nlin6asym_to_anat_xfm = nlin2009c_to_anat_xfm.replace(
-        "from-MNI152NLin2009cAsym_",
+    nlin2009c_to_anat_xfm = nlin6asym_to_anat_xfm.replace(
         "from-MNI152NLin6Asym_",
+        "from-MNI152NLin2009cAsym_",
     )
     (
         xforms_to_mni,
@@ -372,8 +372,8 @@ def test_get_bold2std_and_t1w_xfms(ds001419_data):
         xforms_to_t1w,
         xforms_to_t1w_invert,
     ) = utils.get_bold2std_and_t1w_xfms(
-        bold_file_nlin6asym,
-        nlin6asym_to_anat_xfm,
+        bold_file_nlin2009c,
+        nlin2009c_to_anat_xfm,
     )
     assert len(xforms_to_mni) == 1
     assert len(xforms_to_mni_invert) == 1
@@ -381,12 +381,12 @@ def test_get_bold2std_and_t1w_xfms(ds001419_data):
     assert len(xforms_to_t1w_invert) == 1
 
     # MNIInfant --> MNI152NLin2009cAsym/T1w
-    bold_file_infant = bold_file_nlin2009c.replace(
-        "space-MNI152NLin2009cAsym_",
+    bold_file_infant = bold_file_nlin6asym.replace(
+        "space-MNI152NLin6Asym_",
         "space-MNIInfant_cohort-1_",
     )
-    infant_to_anat_xfm = nlin2009c_to_anat_xfm.replace(
-        "from-MNI152NLin2009cAsym_",
+    infant_to_anat_xfm = nlin6asym_to_anat_xfm.replace(
+        "from-MNI152NLin6Asym_",
         "from-MNIInfant+1_",
     )
     (
@@ -404,15 +404,15 @@ def test_get_bold2std_and_t1w_xfms(ds001419_data):
     assert len(xforms_to_t1w_invert) == 1
 
     # T1w --> MNI152NLin2009cAsym/T1w
-    bold_file_t1w = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "space-T1w_")
+    bold_file_t1w = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "space-T1w_")
     with pytest.raises(ValueError, match="BOLD space 'T1w' not supported."):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_t1w,
-            nlin2009c_to_anat_xfm,
+            nlin6asym_to_anat_xfm,
         )
 
     # T1w --> MNI152NLin6Asym --> MNI152NLin2009cAsym/T1w
-    bold_file_t1w = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "space-T1w_")
+    bold_file_t1w = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "space-T1w_")
     with pytest.raises(ValueError, match="BOLD space 'T1w' not supported."):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_t1w,
@@ -420,15 +420,15 @@ def test_get_bold2std_and_t1w_xfms(ds001419_data):
         )
 
     # native --> MNI152NLin2009cAsym/T1w
-    bold_file_native = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "")
+    bold_file_native = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "")
     with pytest.raises(ValueError, match="BOLD space 'native' not supported."):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_native,
-            nlin2009c_to_anat_xfm,
+            nlin6asym_to_anat_xfm,
         )
 
     # native --> MNI152NLin6Asym --> MNI152NLin2009cAsym/T1w
-    bold_file_native = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "")
+    bold_file_native = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "")
     with pytest.raises(ValueError, match="BOLD space 'native' not supported."):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_native,
@@ -436,14 +436,14 @@ def test_get_bold2std_and_t1w_xfms(ds001419_data):
         )
 
     # tofail --> MNI152NLin2009cAsym/T1w
-    bold_file_tofail = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "space-tofail_")
+    bold_file_tofail = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "space-tofail_")
     with pytest.raises(ValueError, match="Transform does not match BOLD space"):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_tofail,
-            nlin2009c_to_anat_xfm,
+            nlin6asym_to_anat_xfm,
         )
 
-    tofail_to_anat_xfm = nlin2009c_to_anat_xfm.replace("from-MNI152NLin2009cAsym_", "from-tofail_")
+    tofail_to_anat_xfm = nlin6asym_to_anat_xfm.replace("from-MNI152NLin6Asym_", "from-tofail_")
     with pytest.raises(ValueError, match="Space 'tofail'"):
         utils.get_bold2std_and_t1w_xfms(
             bold_file_tofail,
@@ -456,30 +456,30 @@ def test_get_std2bold_xfms(ds001419_data):
 
     get_std2bold_xfms finds transforms to go from the input file's space to MNI152NLin6Asym.
     """
-    bold_file_nlin2009c = ds001419_data["nifti_file"]
+    bold_file_nlin6asym = ds001419_data["nifti_file"]
 
-    # MNI152NLin6Asym --> MNI152NLin2009cAsym
-    xforms_to_mni = utils.get_std2bold_xfms(bold_file_nlin2009c)
+    # MNI152NLin6Asym --> MNI152NLin6Asym
+    xforms_to_mni = utils.get_std2bold_xfms(bold_file_nlin6asym)
     assert len(xforms_to_mni) == 1
 
-    # MNI152NLin6Asym --> MNI152NLin6Asym
-    bold_file_nlin6asym = bold_file_nlin2009c.replace(
-        "space-MNI152NLin2009cAsym_",
+    # MNI152NLin6Asym --> MNI152NLin2009cAsym
+    bold_file_nlin2009c = bold_file_nlin6asym.replace(
         "space-MNI152NLin6Asym_",
+        "space-MNI152NLin2009cAsym_",
     )
-    xforms_to_mni = utils.get_std2bold_xfms(bold_file_nlin6asym)
+    xforms_to_mni = utils.get_std2bold_xfms(bold_file_nlin2009c)
     assert len(xforms_to_mni) == 1
 
     # MNI152NLin6Asym --> MNIInfant
-    bold_file_infant = bold_file_nlin2009c.replace(
-        "space-MNI152NLin2009cAsym_",
+    bold_file_infant = bold_file_nlin6asym.replace(
+        "space-MNI152NLin6Asym_",
         "space-MNIInfant_cohort-1_",
     )
     xforms_to_mni = utils.get_std2bold_xfms(bold_file_infant)
     assert len(xforms_to_mni) == 2
 
     # MNI152NLin6Asym --> tofail
-    bold_file_tofail = bold_file_nlin2009c.replace("space-MNI152NLin2009cAsym_", "space-tofail_")
+    bold_file_tofail = bold_file_nlin6asym.replace("space-MNI152NLin6Asym_", "space-tofail_")
     with pytest.raises(ValueError, match="Space 'tofail'"):
         utils.get_std2bold_xfms(bold_file_tofail)
 
diff --git a/xcp_d/tests/test_utils_write_save.py b/xcp_d/tests/test_utils_write_save.py
index da5030744..a6f6838ca 100644
--- a/xcp_d/tests/test_utils_write_save.py
+++ b/xcp_d/tests/test_utils_write_save.py
@@ -27,7 +27,7 @@ def test_read_ndata(ds001419_data):
         write_save.read_ndata(nifti_file, maskfile=None)
 
     nifti_data = write_save.read_ndata(nifti_file, maskfile=mask_file)
-    assert nifti_data.shape == (249657, 60)
+    assert nifti_data.shape == (242716, 60)
 
 
 def test_write_ndata(ds001419_data, tmp_path_factory):
diff --git a/xcp_d/tests/utils.py b/xcp_d/tests/utils.py
index de6e10752..0cd3d88bb 100644
--- a/xcp_d/tests/utils.py
+++ b/xcp_d/tests/utils.py
@@ -48,8 +48,6 @@ def update_resources(parameters):
     return parameters
 
 
-
-
 def get_nodes(wf_results):
     """Load nodes from a Nipype workflow's results."""
     return {node.fullname: node for node in wf_results.nodes}
@@ -63,6 +61,9 @@ def download_test_data(dset, data_dir=None):
         ),
         "nibabies": "https://upenn.box.com/shared/static/rsd7vpny5imv3qkd7kpuvdy9scpnfpe2.tar.gz",
         "ds001419": "https://upenn.box.com/shared/static/yye7ljcdodj9gd6hm2r6yzach1o6xq1d.tar.gz",
+        "ds001419-aroma": (
+            "https://upenn.box.com/shared/static/dexcmnlj7yujudr3muu05kch66sko4mt.tar.gz"
+        ),
         "pnc": "https://upenn.box.com/shared/static/ui2847ys49d82pgn5ewai1mowcmsv2br.tar.gz",
         "ukbiobank": "https://upenn.box.com/shared/static/p5h1eg4p5cd2ef9ehhljlyh1uku0xe97.tar.gz",
     }
@@ -78,17 +79,17 @@ def download_test_data(dset, data_dir=None):
     if not data_dir:
         data_dir = os.path.join(os.path.dirname(get_test_data_path()), "test_data")
 
-    dset_name = dset
-    if dset == "ds001419":
-        dset_name = "ds001419-fmriprep"
-
-    out_dir = os.path.join(data_dir, dset_name)
+    out_dir = os.path.join(data_dir, dset)
 
     if os.path.isdir(out_dir):
         LOGGER.info(
             f"Dataset {dset} already exists. "
             "If you need to re-download the data, please delete the folder."
         )
+        if dset.startswith("ds001419"):
+            # These test datasets have an extra folder level
+            out_dir = os.path.join(out_dir, dset)
+
         return out_dir
     else:
         LOGGER.info(f"Downloading {dset} to {out_dir}")
@@ -98,6 +99,10 @@ def download_test_data(dset, data_dir=None):
         with tarfile.open(fileobj=GzipFile(fileobj=BytesIO(req.content))) as t:
             t.extractall(out_dir)
 
+    if dset.startswith("ds001419"):
+        # These test datasets have an extra folder level
+        out_dir = os.path.join(out_dir, dset)
+
     return out_dir
 
 
diff --git a/xcp_d/utils/bids.py b/xcp_d/utils/bids.py
index af08cb143..8174c5eb0 100644
--- a/xcp_d/utils/bids.py
+++ b/xcp_d/utils/bids.py
@@ -12,6 +12,7 @@
 
 import nibabel as nb
 import yaml
+from bids.layout import BIDSLayout
 from nipype import logging
 from packaging.version import Version
 
@@ -559,7 +560,7 @@ def collect_run_data(layout, bold_file, file_format, target_space):
     bids_file = layout.get_file(bold_file)
     run_data, metadata = {}, {}
 
-    run_data["confounds"] = layout.get_nearest(
+    run_data["motion_file"] = layout.get_nearest(
         bids_file.path,
         strict=True,
         ignore_strict_entities=["space", "res", "den", "desc", "suffix", "extension"],
@@ -567,10 +568,11 @@ def collect_run_data(layout, bold_file, file_format, target_space):
         suffix="timeseries",
         extension=".tsv",
     )
-    if not run_data["confounds"]:
+    if not run_data["motion_file"]:
         raise FileNotFoundError(f"No confounds file detected for {bids_file.path}")
 
-    run_data["confounds_json"] = layout.get_nearest(run_data["confounds"], extension=".json")
+    run_data["motion_json"] = layout.get_nearest(run_data["motion_file"], extension=".json")
+
     metadata["bold_metadata"] = layout.get_metadata(bold_file)
     # Ensure that we know the TR
     if "RepetitionTime" not in metadata["bold_metadata"].keys():
@@ -655,11 +657,93 @@ def collect_run_data(layout, bold_file, file_format, target_space):
     return run_data
 
 
+def collect_confounds(
+    bold_file: str,
+    preproc_dataset: BIDSLayout,
+    derivatives_datasets: dict[str, Path | BIDSLayout] | None,
+    confound_spec: dict | None,
+):
+    """Gather confounds files from derivatives datasets and compose a cache."""
+    import re
+
+    from bids.layout.index import BIDSLayoutIndexer
+
+    bold_file = preproc_dataset.get_file(bold_file)
+
+    # Recommended after PyBIDS 12.1
+    ignore_patterns = [
+        "code",
+        "stimuli",
+        "models",
+        re.compile(r"\/\.\w+|^\.\w+"),  # hidden files
+        re.compile(
+            r"sub-[a-zA-Z0-9]+(/ses-[a-zA-Z0-9]+)?/(anat|beh|dwi|eeg|ieeg|meg|perf|pet|physio)"
+        ),
+    ]
+    _indexer = BIDSLayoutIndexer(
+        validate=False,
+        ignore=ignore_patterns,
+        index_metadata=False,  # we don't need metadata to find confound files
+    )
+    xcp_d_config = str(load_data("xcp_d_bids_config2.json"))
+
+    # Step 0: Determine derivatives we care about for confounds.
+    req_datasets = []
+    for confound_def in confound_spec["confounds"].values():
+        req_datasets.append(confound_def["dataset"])
+
+    req_datasets = sorted(list(set(req_datasets)))
+
+    # Step 1: Build a dictionary of dataset: layout pairs.
+    layout_dict = {}
+    layout_dict["preprocessed"] = preproc_dataset
+    if derivatives_datasets is not None:
+        for k, v in derivatives_datasets.items():
+            # Don't index datasets we don't need for confounds.
+            if k not in req_datasets:
+                print(f"Not required: {k}")
+                continue
+
+            if isinstance(v, (Path, str)):
+                layout_dict[k] = BIDSLayout(
+                    v,
+                    config=["bids", "derivatives", xcp_d_config],
+                    indexer=_indexer,
+                )
+            else:
+                layout_dict[k] = v
+
+    # Step 2: Loop over the confounds spec and search for each file in the corresponding dataset.
+    confounds = dict()
+    for confound_name, confound_def in confound_spec["confounds"].items():
+        if confound_def["dataset"] not in layout_dict.keys():
+            raise ValueError(
+                f"Missing dataset required by confound spec: *{confound_def['dataset']}*. "
+                "Did you provide it with the `--derivatives` flag?"
+            )
+
+        layout = layout_dict[confound_def["dataset"]]
+        bold_file_entities = bold_file.get_entities()
+        query = {**bold_file_entities, **confound_def["query"]}
+        confound_file = layout.get(**query)
+        if not confound_file:
+            raise FileNotFoundError(
+                f"Could not find confound file for {confound_name} with query {query}"
+            )
+
+        confound_file = confound_file[0]
+        confound_metadata = confound_file.get_metadata()
+        confounds[confound_name] = {}
+        confounds[confound_name]["file"] = confound_file.path
+        confounds[confound_name]["metadata"] = confound_metadata
+
+    return confounds
+
+
 def write_derivative_description(
     fmri_dir,
     output_dir,
     atlases=None,
-    custom_confounds_folder=None,
     dataset_links={},
 ):
     """Write dataset_description.json file for derivatives.
@@ -686,6 +770,7 @@ def write_derivative_description(
     if not os.path.isfile(orig_dset_description):
         raise FileNotFoundError(f"Dataset description DNE: {orig_dset_description}")
 
+    # Base the new dataset description on the preprocessing pipeline's dataset description
     with open(orig_dset_description, "r") as fo:
         desc = json.load(fo)
 
@@ -701,6 +786,7 @@ def write_derivative_description(
         )
 
     # Update dataset description
+    # TODO: Add derivatives' dataset_description.json info as well. Especially the GeneratedBy.
     desc["Name"] = "XCP-D: A Robust Postprocessing Pipeline of fMRI data"
     generated_by = desc.get("GeneratedBy", [])
     generated_by.insert(
@@ -722,18 +808,8 @@ def write_derivative_description(
     if atlases:
         dataset_links["atlases"] = os.path.join(output_dir, "atlases")
 
-    if custom_confounds_folder:
-        dataset_links["custom_confounds"] = str(custom_confounds_folder)
-
-    # Add DatasetLinks
-    if "DatasetLinks" not in desc.keys():
-        desc["DatasetLinks"] = {}
-
-    for k, v in dataset_links.items():
-        if k in desc["DatasetLinks"].keys() and desc["DatasetLinks"][k] != str(v):
-            LOGGER.warning(f"'{k}' is already a dataset link. Overwriting.")
-
-        desc["DatasetLinks"][k] = str(v)
+    # Don't inherit DatasetLinks from preprocessing derivatives
+    desc["DatasetLinks"] = {k: str(v) for k, v in dataset_links.items()}
 
     xcpd_dset_description = Path(output_dir / "dataset_description.json")
     if xcpd_dset_description.is_file():
@@ -741,6 +817,12 @@ def write_derivative_description(
         old_version = old_desc["GeneratedBy"][0]["Version"]
         if Version(__version__).public != Version(old_version).public:
             LOGGER.warning(f"Previous output generated by version {old_version} found.")
+
+        for k, v in desc["DatasetLinks"].items():
+            if k in old_desc["DatasetLinks"].keys() and old_desc["DatasetLinks"][k] != str(v):
+                LOGGER.warning(
+                    f"DatasetLink '{k}' does not match ({v} != {old_desc['DatasetLinks'][k]})."
+                )
     else:
         xcpd_dset_description.write_text(json.dumps(desc, indent=4))
 
@@ -775,9 +857,9 @@ def write_atlas_dataset_description(atlas_dir):
     atlas_dset_description = os.path.join(atlas_dir, "dataset_description.json")
     if os.path.isfile(atlas_dset_description):
         with open(atlas_dset_description, "r") as fo:
-            old_dset_desc = json.load(fo)
+            old_desc = json.load(fo)
 
-        old_version = old_dset_desc["GeneratedBy"][0]["Version"]
+        old_version = old_desc["GeneratedBy"][0]["Version"]
         if Version(__version__).public != Version(old_version).public:
             LOGGER.warning(f"Previous output generated by version {old_version} found.")
 
@@ -1029,6 +1111,81 @@ def group_across_runs(in_files):
     return out_files
 
 
+def _find_nearest_path(path_dict, input_path):
+    """Find the nearest relative path from an input path to a dictionary of paths.
+
+    If ``input_path`` is not relative to any of the paths in ``path_dict``,
+    the absolute path string is returned.
+
+    If ``input_path`` is already a BIDS-URI, then it will be returned unmodified.
+
+    Parameters
+    ----------
+    path_dict : dict of (str, Path)
+        A dictionary of paths.
+    input_path : Path
+        The input path to match.
+
+    Returns
+    -------
+    matching_path : str
+        The nearest relative path from the input path to a path in the dictionary.
+        This is either the concatenation of the associated key from ``path_dict``
+        and the relative path from the associated value from ``path_dict`` to ``input_path``,
+        or the absolute path to ``input_path`` if no matching path is found from ``path_dict``.
+
+    Examples
+    --------
+    >>> from pathlib import Path
+    >>> path_dict = {
+    ...     'bids::': Path('/data/derivatives/fmriprep'),
+    ...     'bids:raw:': Path('/data'),
+    ...     'bids:deriv-0:': Path('/data/derivatives/source-1'),
+    ... }
+    >>> input_path = Path('/data/derivatives/source-1/sub-01/func/sub-01_task-rest_bold.nii.gz')
+    >>> _find_nearest_path(path_dict, input_path)  # match to 'bids:deriv-0:'
+    'bids:deriv-0:sub-01/func/sub-01_task-rest_bold.nii.gz'
+    >>> input_path = Path('/out/sub-01/func/sub-01_task-rest_bold.nii.gz')
+    >>> _find_nearest_path(path_dict, input_path)  # no match- absolute path
+    '/out/sub-01/func/sub-01_task-rest_bold.nii.gz'
+    >>> input_path = Path('/data/sub-01/func/sub-01_task-rest_bold.nii.gz')
+    >>> _find_nearest_path(path_dict, input_path)  # match to 'bids:raw:'
+    'bids:raw:sub-01/func/sub-01_task-rest_bold.nii.gz'
+    >>> input_path = 'bids::sub-01/func/sub-01_task-rest_bold.nii.gz'
+    >>> _find_nearest_path(path_dict, input_path)  # already a BIDS-URI
+    'bids::sub-01/func/sub-01_task-rest_bold.nii.gz'
+    """
+    # Don't modify BIDS-URIs
+    if isinstance(input_path, str) and input_path.startswith("bids:"):
+        return input_path
+
+    input_path = Path(input_path)
+    matching_path = None
+    for key, path in path_dict.items():
+        if input_path.is_relative_to(path):
+            relative_path = input_path.relative_to(path)
+            if (matching_path is None) or (len(relative_path.parts) < len(matching_path.parts)):
+                matching_key = key
+                matching_path = relative_path
+
+    if matching_path is None:
+        matching_path = str(input_path.absolute())
+    else:
+        matching_path = f"{matching_key}{matching_path}"
+
+    return matching_path
+
+
+def make_bids_uri(in_files, dataset_links, out_dir):
+    """Create a BIDS-URI for each input file."""
+    # Convert the dataset links to BIDS URI prefixes
+    updated_keys = {f"bids:{k}:": Path(v) for k, v in dataset_links.items()}
+    updated_keys["bids::"] = Path(out_dir)
+    # Convert the paths to BIDS URIs
+    bids_uris = [_find_nearest_path(updated_keys, f) for f in in_files]
+    return bids_uris
+
+
 def _make_uri(in_file, dataset_name, dataset_path):
     """Convert a filename to a BIDS URI.
 
@@ -1089,18 +1246,6 @@ def _make_preproc_uri(out_file, fmri_dir):
         return [_make_uri(out_file, "preprocessed", fmri_dir)]
 
 
-def _make_custom_uri(out_file):
-    """Convert custom confounds' path to BIDS URI."""
-    import os
-
-    from xcp_d.utils.bids import _make_uri
-
-    if isinstance(out_file, list):
-        return [_make_uri(of, "custom_confounds", os.path.dirname(of)) for of in out_file]
-    else:
-        return [_make_uri(out_file, "custom_confounds", os.path.dirname(out_file))]
-
-
 def check_pipeline_version(pipeline_name, cvers, data_desc):
     """Search for existing BIDS pipeline output and compares against current pipeline version.
 
diff --git a/xcp_d/utils/boilerplate.py b/xcp_d/utils/boilerplate.py
index 892321a40..089e288b6 100644
--- a/xcp_d/utils/boilerplate.py
+++ b/xcp_d/utils/boilerplate.py
@@ -12,7 +12,6 @@ def describe_motion_parameters(
     motion_filter_order,
     band_stop_min,
     band_stop_max,
-    head_radius,
     TR,
 ):
     """Build a text description of the motion parameter filtering and FD calculation process.
@@ -23,7 +22,6 @@ def describe_motion_parameters(
     %(motion_filter_order)s
     %(band_stop_min)s
     %(band_stop_max)s
-    %(head_radius)s
     %(TR)s
 
     Returns
@@ -81,22 +79,17 @@ def describe_motion_parameters(
 
         desc += "The Volterra expansion of these filtered motion parameters was then calculated. "
 
-    desc += (
-        "Framewise displacement was calculated from the "
-        f"{'filtered ' if motion_filter_type else ''}motion parameters using the formula from "
-        f"@power_fd_dvars, with a head radius of {head_radius} mm. "
-    )
-
     return desc
 
 
 @fill_doc
-def describe_censoring(motion_filter_type, fd_thresh, exact_scans):
+def describe_censoring(*, motion_filter_type, head_radius, fd_thresh, exact_scans):
     """Build a text description of the FD censoring process.
 
     Parameters
     ----------
     %(motion_filter_type)s
+    %(head_radius)s
     %(fd_thresh)s
     %(exact_scans)s
 
@@ -108,6 +101,9 @@ def describe_censoring(motion_filter_type, fd_thresh, exact_scans):
     desc = ""
     if fd_thresh > 0:
         desc += (
+            "Framewise displacement was calculated from the "
+            f"{'filtered ' if motion_filter_type else ''}motion parameters using the formula from "
+            f"@power_fd_dvars, with a head radius of {head_radius} mm. "
             f"Volumes with {'filtered ' if motion_filter_type else ''}framewise displacement "
             f"greater than {fd_thresh} mm were flagged as high-motion outliers for the sake of "
             "later censoring [@power_fd_dvars]."
@@ -128,13 +124,21 @@ def describe_censoring(motion_filter_type, fd_thresh, exact_scans):
 
 
 @fill_doc
-def describe_regression(params, custom_confounds_file, motion_filter_type):
+def describe_regression(
+    *,
+    confounds_config,
+    motion_filter_type,
+    motion_filter_order,
+    band_stop_min,
+    band_stop_max,
+    TR,
+    fd_thresh,
+):
     """Build a text description of the regression that will be performed.
 
     Parameters
     ----------
-    %(params)s
-    %(custom_confounds_file)s
+    confounds_config
     %(motion_filter_type)s
 
     Returns
@@ -142,113 +146,25 @@ def describe_regression(params, custom_confounds_file, motion_filter_type):
     desc : :obj:`str`
         A text description of the regression.
     """
-    import pandas as pd
+    if confounds_config is None:
+        return "No nuisance regression was performed."
 
-    use_custom_confounds, orth = False, False
-    if custom_confounds_file is not None:
-        use_custom_confounds = True
-        custom_confounds = pd.read_table(custom_confounds_file)
-        orth = any([c.startswith("signal__") for c in custom_confounds.columns])
+    desc = confounds_config["description"]
 
-    fstr = "filtered " if motion_filter_type else ""
-
-    BASE_DESCRIPTIONS = {
-        "custom": "A custom set of regressors was used, with no other regressors from XCP-D.",
-        "none": "No nuisance regression was performed.",
-        "24P": (
-            "In total, 24 nuisance regressors were selected from the preprocessing confounds, "
-            "according to the '24P' strategy. "
-            "These nuisance regressors included "
-            f"six {fstr}motion parameters with their temporal derivatives, "
-            "and their quadratic expansion of those six motion parameters and their "
-            "temporal derivatives [@benchmarkp;@satterthwaite_2013]."
-        ),
-        "27P": (
-            "In total, 27 nuisance regressors were selected from the preprocessing confounds, "
-            "according to the '27P' strategy. "
-            "These nuisance regressors included "
-            f"six {fstr}motion parameters with their temporal derivatives, "
-            "quadratic expansion of those six motion parameters and their derivatives, "
-            "mean global signal, mean white matter signal, and mean cerebrospinal fluid signal "
-            "[@benchmarkp;@satterthwaite_2013]."
-        ),
-        "36P": (
-            "In total, 36 nuisance regressors were selected from the preprocessing confounds, "
-            "according to the '36P' strategy. "
-            "These nuisance regressors included "
-            f"six {fstr}motion parameters, mean global signal, mean white matter signal, "
-            "mean cerebrospinal fluid signal with their temporal derivatives, "
-            "and quadratic expansion of six motion parameters, tissue signals and "
-            "their temporal derivatives [@benchmarkp;@satterthwaite_2013]."
-        ),
-        "acompcor": (
-            "Nuisance regressors were selected according to the 'acompcor' strategy. "
-            "The top 5 aCompCor principal components from the white matter and "
-            "cerebrospinal fluid compartments were selected as nuisance regressors "
-            "[@behzadi2007component], "
-            f"along with the six {fstr}motion parameters and their temporal derivatives "
-            "[@benchmarkp;@satterthwaite_2013]. "
-            "As the aCompCor regressors were generated on high-pass filtered data, "
-            "the associated cosine basis regressors were included. "
-            "This has the effect of high-pass filtering the data as well."
-        ),
-        "acompcor_gsr": (
-            "Nuisance regressors were selected according to the 'acompcor_gsr' strategy. "
-            "The top 5 aCompCor principal components from the white matter and "
-            "cerebrospinal fluid compartments were selected as nuisance regressors "
-            "[@behzadi2007component], "
-            f"along with the six {fstr}motion parameters and their temporal derivatives, "
-            "mean white matter signal, mean cerebrospinal fluid signal, and mean global signal "
-            "[@benchmarkp;@satterthwaite_2013]. "
-            "As the aCompCor regressors were generated on high-pass filtered data, "
-            "the associated cosine basis regressors were included. "
-            "This has the effect of high-pass filtering the data as well."
-        ),
-        "aroma": (
-            "Nuisance regressors were selected according to the 'aroma' strategy. "
-            "AROMA motion-labeled components [@pruim2015ica], mean white matter signal, "
-            "and mean cerebrospinal fluid signal were selected as nuisance regressors "
-            "[@benchmarkp;@satterthwaite_2013]."
-        ),
-        "aroma_gsr": (
-            "Nuisance regressors were selected according to the 'aroma_gsr' strategy. "
-            "AROMA motion-labeled components [@pruim2015ica], mean white matter signal, "
-            "mean cerebrospinal fluid signal, and mean global signal were selected as "
-            "nuisance regressors [@benchmarkp;@satterthwaite_2013]."
-        ),
-        "gsr_only": (
-            "Nuisance regressors were selected according to the 'gsr_only' strategy. "
-            "Mean global signal was selected as the only nuisance regressor."
-        ),
-    }
-
-    if params not in BASE_DESCRIPTIONS.keys():
-        raise ValueError(f"Unrecognized parameter string '{params}'")
-
-    desc = BASE_DESCRIPTIONS[params]
-    if use_custom_confounds and params != "custom":
-        desc += " Additionally, custom confounds were also included as nuisance regressors."
-
-    if "aroma" not in params and orth:
+    if (fd_thresh > 0) and motion_filter_type:
+        # Censoring was done, so just refer back to the earlier description of the filter
         desc += (
-            " Custom confounds prefixed with 'signal__' were used to account for variance "
-            "explained by known signals. "
-            "Prior to denoising the BOLD data, the nuisance confounds were orthogonalized "
-            "with respect to the signal regressors."
+            " Any motion parameters in the confounds file were filtered using the same "
+            "parameters as described above and the Volterra expansion was calculated."
         )
-    elif "aroma" in params and not orth:
-        desc += (
-            " AROMA non-motion components (i.e., ones assumed to reflect signal) were used to "
-            "account for variance by known signals. "
-            "Prior to denoising the BOLD data, the nuisance confounds were orthogonalized "
-            "with respect to the non-motion components."
-        )
-
-    if "aroma" in params or orth:
-        desc += (
-            " In this way, the confound regressors were orthogonalized to produce regressors "
-            "without variance explained by known signals, so that signal would not be removed "
-            "from the BOLD data in the later regression."
+    elif motion_filter_type:
+        # Censoring was not done, so describe the filter here
+        desc += " " + describe_motion_parameters(
+            motion_filter_type=motion_filter_type,
+            motion_filter_order=motion_filter_order,
+            band_stop_min=band_stop_min,
+            band_stop_max=band_stop_max,
+            TR=TR,
         )
 
     return desc
diff --git a/xcp_d/utils/confounds.py b/xcp_d/utils/confounds.py
index 28f645488..42900bda4 100644
--- a/xcp_d/utils/confounds.py
+++ b/xcp_d/utils/confounds.py
@@ -1,13 +1,12 @@
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """Confound matrix selection based on Ciric et al. 2007."""
-import json
 import os
 import warnings
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
-from nilearn.interfaces.fmriprep.load_confounds import _load_single_confounds_file
 from nipype import logging
 from scipy.signal import butter, filtfilt, iirnotch
 
@@ -16,6 +15,23 @@
 LOGGER = logging.getLogger("nipype.utils")
 
 
+def volterra(df):
+    """Perform Volterra expansion."""
+    # Ignore pandas SettingWithCopyWarning
+    with pd.option_context("mode.chained_assignment", None):
+        columns = df.columns.tolist()
+        for col in columns:
+            new_col = f"{col}_derivative1"
+            df[new_col] = df[col].diff()
+
+        columns = df.columns.tolist()
+        for col in columns:
+            new_col = f"{col}_power2"
+            df[new_col] = df[col] ** 2
+
+    return df
+
+
 @fill_doc
 def load_motion(
     confounds_df,
@@ -44,6 +60,7 @@ def load_motion(
     motion_confounds_df : pandas.DataFrame
         The six motion regressors.
         The three rotations are listed first, then the three translations.
+        Plus rmsd, and possibly filtered motion regressors.
 
     References
     ----------
@@ -53,13 +70,16 @@ def load_motion(
         raise ValueError(f"Motion filter type '{motion_filter_type}' not supported.")
 
     # Select the motion columns from the overall confounds DataFrame
+    if isinstance(confounds_df, (str, Path)):
+        confounds_df = pd.read_table(confounds_df)
+
     motion_confounds_df = confounds_df[
         ["rot_x", "rot_y", "rot_z", "trans_x", "trans_y", "trans_z"]
     ]
 
     # Apply LP or notch filter
     if motion_filter_type in ("lp", "notch"):
-        motion_confounds = motion_regression_filter(
+        motion_confounds = filter_motion(
             data=motion_confounds_df.to_numpy(),
             TR=TR,
             motion_filter_type=motion_filter_type,
@@ -67,278 +87,32 @@ def load_motion(
             band_stop_max=band_stop_max,
             motion_filter_order=motion_filter_order,
         )
-        motion_confounds_df = pd.DataFrame(
+        filtered_motion_confounds_df = pd.DataFrame(
             data=motion_confounds,
-            columns=motion_confounds_df.columns,
+            columns=[f"{c}_filtered" for c in motion_confounds_df.columns],
         )
-
-    # Volterra expansion
-    # Ignore pandas SettingWithCopyWarning
-    with pd.option_context("mode.chained_assignment", None):
-        columns = motion_confounds_df.columns.tolist()
-        for col in columns:
-            new_col = f"{col}_derivative1"
-            motion_confounds_df[new_col] = motion_confounds_df[col].diff()
-
-        columns = motion_confounds_df.columns.tolist()
-        for col in columns:
-            new_col = f"{col}_power2"
-            motion_confounds_df[new_col] = motion_confounds_df[col] ** 2
-
-    return motion_confounds_df
-
-
-@fill_doc
-def get_custom_confounds(custom_confounds_folder, fmriprep_confounds_file):
-    """Identify a custom confounds file.
-
-    Parameters
-    ----------
-    %(custom_confounds_folder)s
-    %(fmriprep_confounds_file)s
-        We expect the custom confounds file to have the same name.
-
-    Returns
-    -------
-    %(custom_confounds_file)s
-    """
-    import os
-
-    if custom_confounds_folder is None:
-        return None
-
-    if not os.path.isdir(custom_confounds_folder):
-        raise FileNotFoundError(
-            f"Custom confounds location does not exist: {custom_confounds_folder}"
+        motion_confounds_df = pd.concat(
+            [motion_confounds_df, filtered_motion_confounds_df],
+            axis=1,
         )
 
-    custom_confounds_filename = os.path.basename(fmriprep_confounds_file)
-    custom_confounds_file = os.path.abspath(
-        os.path.join(
-            custom_confounds_folder,
-            custom_confounds_filename,
-        )
+    # Add RMSD column (used for QC measures later on)
+    motion_confounds_df = pd.concat(
+        [motion_confounds_df, confounds_df[["rmsd"]]],
+        axis=1,
     )
 
-    if not os.path.isfile(custom_confounds_file):
-        raise FileNotFoundError(f"Custom confounds file not found: {custom_confounds_file}")
-
-    return custom_confounds_file
-
-
-def _get_acompcor_confounds(confounds_file):
-    confounds_df = pd.read_table(confounds_file)
-    csf_compcor_columns = [c for c in confounds_df.columns if c.startswith("c_comp_cor")]
-    wm_compcor_columns = [c for c in confounds_df.columns if c.startswith("w_comp_cor")]
-    if not csf_compcor_columns:
-        raise ValueError(f"No c_comp_cor columns in {confounds_file}")
-
-    if not wm_compcor_columns:
-        raise ValueError(f"No w_comp_cor columns in {confounds_file}")
-
-    csf_compcor_columns = csf_compcor_columns[: min((5, len(csf_compcor_columns)))]
-    wm_compcor_columns = wm_compcor_columns[: min((5, len(wm_compcor_columns)))]
-    selected_columns = csf_compcor_columns + wm_compcor_columns
-    return confounds_df[selected_columns]
-
-
-@fill_doc
-def load_confound_matrix(
-    params,
-    img_file,
-    confounds_file,
-    confounds_json_file,
-    custom_confounds=None,
-):
-    """Load a subset of the confounds associated with a given file.
-
-    Parameters
-    ----------
-    %(params)s
-    img_file : :obj:`str`
-        The path to the bold file. Used to load the AROMA mixing matrix, if necessary.
-    confounds_file : :obj:`str`
-        The fMRIPrep confounds file. Used to load most confounds.
-    confounds_json_file : :obj:`str`
-        The JSON file associated with the fMRIPrep confounds file.
-    custom_confounds : :obj:`str` or None, optional
-        Custom confounds TSV if there is one. Default is None.
-
-    Returns
-    -------
-    confounds_df : :obj:`pandas.DataFrame` or None
-        The loaded and selected confounds.
-        If "AROMA" is requested, then this DataFrame will include signal components as well.
-        These will be named something like "signal_[XX]".
-        If ``params`` is "none", ``confounds_df`` will be None.
-    confounds_metadata : :obj:`dict`
-        Metadata for the columns in the confounds file.
-    """
-    PARAM_KWARGS = {
-        # Get rot and trans values, as well as derivatives and square
-        "24P": {
-            "strategy": ["motion"],
-            "motion": "full",
-        },
-        # Get rot and trans values, as well as derivatives and square, WM, CSF,
-        "27P": {
-            "strategy": ["motion", "global_signal", "wm_csf"],
-            "motion": "full",
-            "global_signal": "basic",
-            "wm_csf": "basic",
-        },
-        # Get rot and trans values, as well as derivatives, WM, CSF,
-        # global signal, and square. Add the square and derivative of the WM, CSF
-        # and global signal as well.
-        "36P": {
-            "strategy": ["motion", "global_signal", "wm_csf"],
-            "motion": "full",
-            "global_signal": "full",
-            "wm_csf": "full",
-        },
-        # Get the rot and trans values, their derivative,
-        # as well as acompcor and cosine
-        "acompcor": {
-            "strategy": ["motion", "high_pass", "compcor"],
-            "motion": "derivatives",
-            "compcor": "anat_separated",
-            "n_compcor": 5,
-        },
-        # Get the rot and trans values, as well as their derivative,
-        # acompcor and cosine values as well as global signal
-        "acompcor_gsr": {
-            "strategy": ["motion", "high_pass", "compcor", "global_signal"],
-            "motion": "derivatives",
-            "compcor": "anat_separated",
-            "global_signal": "basic",
-            "n_compcor": 5,
-        },
-        # Get WM and CSF
-        # AROMA confounds are loaded separately
-        "aroma": {
-            "strategy": ["wm_csf"],
-            "wm_csf": "basic",
-        },
-        # Get WM, CSF, and global signal
-        # AROMA confounds are loaded separately
-        "aroma_gsr": {
-            "strategy": ["wm_csf", "global_signal"],
-            "wm_csf": "basic",
-            "global_signal": "basic",
-        },
-        # Get global signal only
-        "gsr_only": {
-            "strategy": ["global_signal"],
-            "global_signal": "basic",
-        },
-    }
-
-    if params == "none":
-        return None, {}
-
-    if params in PARAM_KWARGS:
-        kwargs = PARAM_KWARGS[params]
-
-        confounds_df = _load_single_confounds_file(
-            confounds_file=confounds_file,
-            demean=False,
-            confounds_json_file=confounds_json_file,
-            **kwargs,
-        )[1]
-
-    elif params == "custom":
-        # For custom confounds with no other confounds
-        confounds_df = pd.read_table(custom_confounds, sep="\t")
-
-    else:
-        raise ValueError(f"Unrecognized parameter string '{params}'")
-
-    # A workaround for the compcor bug in load_confounds with fMRIPrep v22+
-    if "acompcor" in params and all("comp_cor" not in col for col in confounds_df.columns):
-        LOGGER.warning("No aCompCor confounds detected with load_confounds. Extracting manually.")
-        confounds_df = pd.concat((_get_acompcor_confounds(confounds_file), confounds_df), axis=1)
-
-    if "aroma" in params:
-        ica_mixing_matrix = _get_mixing_matrix(img_file)
-        aroma_noise_comps_idx = _get_aroma_noise_comps(img_file)
-        labeled_ica_mixing_matrix = _label_mixing_matrix(ica_mixing_matrix, aroma_noise_comps_idx)
-        confounds_df = pd.concat([confounds_df, labeled_ica_mixing_matrix], axis=1)
-
-    if params != "custom" and custom_confounds is not None:
-        # For both custom and fMRIPrep confounds
-        custom_confounds_df = pd.read_table(custom_confounds, sep="\t")
-        confounds_df = pd.concat([custom_confounds_df, confounds_df], axis=1)
-
-    with open(confounds_json_file, "r") as fo:
-        full_confounds_metadata = json.load(fo)
-
-    confounds_metadata = {
-        k: v for k, v in full_confounds_metadata.items() if k in confounds_df.columns
-    }
-
-    return confounds_df, confounds_metadata
-
-
-def _get_mixing_matrix(img_file):
-    """Find AROMA (i.e., MELODIC) mixing matrix file for a given BOLD file."""
-    suffix = "_space-" + img_file.split("space-")[1]
-
-    mixing_candidates = [
-        img_file.replace(suffix, "_desc-MELODIC_mixing.tsv"),
-    ]
-
-    mixing_file = [cr for cr in mixing_candidates if os.path.isfile(cr)]
-
-    if not mixing_file:
-        raise FileNotFoundError(f"Could not find mixing matrix for {img_file}")
-
-    return mixing_file[0]
-
-
-def _get_aroma_noise_comps(img_file):
-    """Find AROMA noise components file for a given BOLD file."""
-    suffix = "_space-" + img_file.split("space-")[1]
-
-    index_candidates = [
-        img_file.replace(suffix, "_AROMAnoiseICs.csv"),
-    ]
-
-    index_file = [cr for cr in index_candidates if os.path.isfile(cr)]
-
-    if not index_file:
-        raise FileNotFoundError(f"Could not find AROMAnoiseICs file for {img_file}")
-
-    return index_file[0]
-
-
-def _label_mixing_matrix(mixing_file, noise_index_file):
-    """Prepend 'signal__' to any non-noise components in AROMA mixing matrix."""
-    mixing_matrix = np.loadtxt(mixing_file, delimiter="\t")
-    noise_index = np.loadtxt(noise_index_file, delimiter=",", dtype=int)
-    # shift noise index to start with zero
-    noise_index -= 1
-    all_index = np.arange(mixing_matrix.shape[1], dtype=int)
-    signal_index = np.setdiff1d(all_index, noise_index)
-    noise_components = mixing_matrix[:, noise_index]
-    signal_components = mixing_matrix[:, signal_index]
-    # basing naming convention on fMRIPrep confounds column names
-    noise_component_names = [f"aroma_motion_{i:03g}" for i in noise_index]
-    signal_component_names = [f"signal__aroma_signal_{i:03g}" for i in signal_index]
-
-    noise_component_df = pd.DataFrame(noise_components, columns=noise_component_names)
-    signal_component_df = pd.DataFrame(signal_components, columns=signal_component_names)
-    component_df = pd.concat((noise_component_df, signal_component_df), axis=1)
-    return component_df
+    return motion_confounds_df
 
 
 @fill_doc
-def motion_regression_filter(
+def filter_motion(
     data,
     TR,
     motion_filter_type,
     band_stop_min,
     band_stop_max,
-    motion_filter_order=4,
+    motion_filter_order,
 ):
     """Filter translation and rotation motion parameters.
 
diff --git a/xcp_d/utils/doc.py b/xcp_d/utils/doc.py
index cf778a173..7e0f8495c 100644
--- a/xcp_d/utils/doc.py
+++ b/xcp_d/utils/doc.py
@@ -101,9 +101,9 @@
 """
 
 docdict[
-    "fmriprep_confounds_file"
+    "preproc_confounds_file"
 ] = """
-fmriprep_confounds_file : :obj:`str`
+preproc_confounds_file : :obj:`str`
     Confounds TSV file from preprocessing derivatives.
 """
 
@@ -158,13 +158,6 @@
     selected.
 """
 
-docdict[
-    "custom_confounds_file"
-] = """
-custom_confounds_file : :obj:`str` or None
-    Path to custom nuisance regressors.
-"""
-
 docdict[
     "head_radius"
 ] = """
@@ -430,9 +423,9 @@
 """
 
 docdict[
-    "filtered_motion"
+    "motion_file"
 ] = """
-filtered_motion : :obj:`str`
+motion_file : :obj:`str`
     Framewise displacement timeseries, potentially after bandstop or low-pass filtering.
     This is a TSV file with one column: 'framewise_displacement'.
 """
diff --git a/xcp_d/utils/modified_data.py b/xcp_d/utils/modified_data.py
index 15bd79102..e2c0391e3 100644
--- a/xcp_d/utils/modified_data.py
+++ b/xcp_d/utils/modified_data.py
@@ -16,7 +16,7 @@
 
 
 @fill_doc
-def compute_fd(confound, head_radius=50):
+def compute_fd(confound, head_radius=50, filtered=False):
     """Compute framewise displacement.
 
     NOTE: TS- Which kind of FD? Power?
@@ -34,7 +34,11 @@ def compute_fd(confound, head_radius=50):
         The framewise displacement time series.
     """
     confound = confound.replace(np.nan, 0)
-    mpars = confound[["trans_x", "trans_y", "trans_z", "rot_x", "rot_y", "rot_z"]].to_numpy()
+    motion_columns = ["trans_x", "trans_y", "trans_z", "rot_x", "rot_y", "rot_z"]
+    if filtered:
+        motion_columns = [f"{col}_filtered" for col in motion_columns]
+
+    mpars = confound[motion_columns].to_numpy()
     diff = mpars[:-1, :6] - mpars[1:, :6]
     diff[:, 3:6] *= head_radius
     fd_res = np.abs(diff).sum(axis=1)
@@ -137,7 +141,7 @@ def downcast_to_32(in_file):
 
 @fill_doc
 def flag_bad_run(
-    fmriprep_confounds_file,
+    motion_file,
     dummy_scans,
     TR,
     motion_filter_type,
@@ -151,7 +155,8 @@ def flag_bad_run(
 
     Parameters
     ----------
-    %(fmriprep_confounds_file)s
+    motion_file
+        Tabular confounds file containing motion parameters.
     %(dummy_scans)s
     %(TR)s
     %(motion_filter_type)s
@@ -173,11 +178,11 @@ def flag_bad_run(
 
     dummy_scans = _infer_dummy_scans(
         dummy_scans=dummy_scans,
-        confounds_file=fmriprep_confounds_file,
+        confounds_file=motion_file,
     )
 
     # Read in fmriprep confounds tsv to calculate FD
-    fmriprep_confounds_df = pd.read_table(fmriprep_confounds_file)
+    fmriprep_confounds_df = pd.read_table(motion_file)
 
     # Remove dummy volumes
     fmriprep_confounds_df = fmriprep_confounds_df.drop(np.arange(dummy_scans))
@@ -197,7 +202,11 @@ def flag_bad_run(
         band_stop_min=band_stop_min_adjusted,
         band_stop_max=band_stop_max_adjusted,
     )
-    fd_arr = compute_fd(confound=motion_df, head_radius=head_radius)
+    fd_arr = compute_fd(
+        confound=motion_df,
+        head_radius=head_radius,
+        filtered=bool(motion_filter_type),
+    )
     return np.sum(fd_arr <= fd_thresh) * TR
 
 
diff --git a/xcp_d/utils/plotting.py b/xcp_d/utils/plotting.py
index 354373282..b37f0b50e 100644
--- a/xcp_d/utils/plotting.py
+++ b/xcp_d/utils/plotting.py
@@ -483,7 +483,7 @@ def plot_fmri_es(
     preprocessed_bold,
     denoised_interpolated_bold,
     TR,
-    filtered_motion,
+    motion_file,
     temporal_mask,
     preprocessed_figure,
     denoised_figure,
@@ -501,7 +501,7 @@ def plot_fmri_es(
         Preprocessed BOLD file, dummy scan removal.
     %(denoised_interpolated_bold)s
     %(TR)s
-    %(filtered_motion)s
+    %(motion_file)s
     %(temporal_mask)s
         Only non-outlier (low-motion) volumes in the temporal mask will be used to scale
         the carpet plot.
@@ -548,7 +548,12 @@ def plot_fmri_es(
         }
     )
 
-    fd_regressor = pd.read_table(filtered_motion)["framewise_displacement"].values
+    motion_df = pd.read_table(motion_file)
+    if "framewise_displacement_filtered" in motion_df.columns:
+        fd_regressor = motion_df["framewise_displacement_filtered"].values
+    else:
+        fd_regressor = motion_df["framewise_displacement"].values
+
     if temporal_mask:
         tmask_arr = pd.read_table(temporal_mask)["framewise_displacement"].values.astype(bool)
     else:
diff --git a/xcp_d/workflows/base.py b/xcp_d/workflows/base.py
index a47589852..760a8c01f 100644
--- a/xcp_d/workflows/base.py
+++ b/xcp_d/workflows/base.py
@@ -5,6 +5,7 @@
 import os
 import sys
 from copy import deepcopy
+from pathlib import Path
 
 import bids
 import matplotlib
@@ -13,6 +14,7 @@
 import numpy as np
 import scipy
 import templateflow
+import yaml
 from nipype import __version__ as nipype_ver
 from nipype import logging
 from nipype.interfaces import utility as niu
@@ -26,6 +28,7 @@
 from xcp_d.interfaces.report import AboutSummary, SubjectSummary
 from xcp_d.utils.bids import (
     _get_tr,
+    collect_confounds,
     collect_data,
     collect_mesh_data,
     collect_morphometry_data,
@@ -391,8 +394,7 @@ def init_single_subject_wf(subject_id: str):
             merge_elements = [
                 "name_source",
                 "preprocessed_bold",
-                "fmriprep_confounds_file",
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "denoised_bold",
                 "denoised_interpolated_bold",
@@ -418,9 +420,19 @@ def init_single_subject_wf(subject_id: str):
                 file_format=config.workflow.file_format,
                 target_space=target_space,
             )
+            if isinstance(config.execution.confounds_config, Path):
+                confounds_dict = collect_confounds(
+                    bold_file=bold_file,
+                    preproc_dataset=config.execution.layout,
+                    derivatives_datasets=config.execution.derivatives,
+                    confound_spec=yaml.safe_load(config.execution.confounds_config.read_text()),
+                )
+                run_data["confounds"] = confounds_dict
+            else:
+                run_data["confounds"] = None
 
             post_scrubbing_duration = flag_bad_run(
-                fmriprep_confounds_file=run_data["confounds"],
+                motion_file=run_data["motion_file"],
                 dummy_scans=config.workflow.dummy_scans,
                 TR=run_data["bold_metadata"]["RepetitionTime"],
                 motion_filter_type=config.workflow.motion_filter_type,
diff --git a/xcp_d/workflows/bold/cifti.py b/xcp_d/workflows/bold/cifti.py
index 99bbfa446..03bb716e4 100644
--- a/xcp_d/workflows/bold/cifti.py
+++ b/xcp_d/workflows/bold/cifti.py
@@ -10,7 +10,6 @@
 
 from xcp_d import config
 from xcp_d.interfaces.utils import ConvertTo32
-from xcp_d.utils.confounds import get_custom_confounds
 from xcp_d.utils.doc import fill_doc
 from xcp_d.utils.utils import _create_mem_gb
 from xcp_d.workflows.bold.connectivity import init_functional_connectivity_cifti_wf
@@ -98,15 +97,14 @@ def init_postprocess_cifti_wf(
     bold_file
         CIFTI file
     %(boldref)s
-    %(custom_confounds_file)s
     t1w
         Preprocessed T1w image, warped to standard space.
         Fed from the subject workflow.
     t2w
         Preprocessed T2w image, warped to standard space.
         Fed from the subject workflow.
-    %(fmriprep_confounds_file)s
-    fmriprep_confounds_json
+    motion_file
+    motion_json
     %(dummy_scans)s
 
     Outputs
@@ -114,9 +112,7 @@ def init_postprocess_cifti_wf(
     %(name_source)s
     preprocessed_bold : :obj:`str`
         The preprocessed BOLD file, after dummy scan removal.
-    %(fmriprep_confounds_file)s
-        After dummy scan removal.
-    %(filtered_motion)s
+    motion_file
     %(temporal_mask)s
     %(denoised_interpolated_bold)s
     %(censored_denoised_bold)s
@@ -134,7 +130,6 @@ def init_postprocess_cifti_wf(
     workflow = Workflow(name=name)
 
     bandpass_filter = config.workflow.bandpass_filter
-    custom_confounds_folder = config.execution.custom_confounds
     dummy_scans = config.workflow.dummy_scans
     despike = config.workflow.despike
     atlases = config.execution.atlases
@@ -146,16 +141,17 @@ def init_postprocess_cifti_wf(
             fields=[
                 "bold_file",
                 "boldref",
-                "custom_confounds_file",
                 "t1w",
                 "t2w",
-                "fmriprep_confounds_file",
-                "fmriprep_confounds_json",
+                "motion_file",
+                "motion_json",
+                "confounds_files",
                 "dummy_scans",
                 # if parcellation is performed
                 "atlases",
                 "atlas_files",
                 "atlas_labels_files",
+                # CIFTI only
                 # for plotting, if the anatomical workflow was used
                 "lh_midthickness",
                 "rh_midthickness",
@@ -166,19 +162,12 @@ def init_postprocess_cifti_wf(
 
     inputnode.inputs.bold_file = bold_file
     inputnode.inputs.boldref = run_data["boldref"]
-    inputnode.inputs.fmriprep_confounds_file = run_data["confounds"]
-    inputnode.inputs.fmriprep_confounds_json = run_data["confounds_json"]
+    inputnode.inputs.motion_file = run_data["motion_file"]
+    inputnode.inputs.motion_json = run_data["motion_json"]
+    inputnode.inputs.confounds_files = run_data["confounds"]
     inputnode.inputs.dummy_scans = dummy_scans
     inputnode.inputs.atlases = atlases
 
-    # Load custom confounds
-    # We need to run this function directly to access information in the confounds that is
-    # used for the boilerplate.
-    custom_confounds_file = get_custom_confounds(
-        custom_confounds_folder,
-        run_data["confounds"],
-    )
-
     workflow = Workflow(name=name)
 
     workflow.__desc__ = f"""\
@@ -193,8 +182,7 @@ def init_postprocess_cifti_wf(
             fields=[
                 "name_source",
                 "preprocessed_bold",
-                "fmriprep_confounds_file",
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "denoised_bold",
                 "denoised_interpolated_bold",
@@ -230,20 +218,17 @@ def init_postprocess_cifti_wf(
         TR=TR,
         exact_scans=exact_scans,
         head_radius=head_radius,
-        custom_confounds_file=custom_confounds_file,
     )
 
     workflow.connect([
         (inputnode, prepare_confounds_wf, [
             ("bold_file", "inputnode.name_source"),
-            ("fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
-            ("fmriprep_confounds_json", "inputnode.fmriprep_confounds_json"),
-        ]),
-        (downcast_data, prepare_confounds_wf, [
-            ("bold_file", "inputnode.preprocessed_bold"),
+            ("motion_file", "inputnode.motion_file"),
+            ("motion_json", "inputnode.motion_json"),
+            ("confounds_files", "inputnode.confounds_files"),
         ]),
+        (downcast_data, prepare_confounds_wf, [("bold_file", "inputnode.preprocessed_bold")]),
         (prepare_confounds_wf, outputnode, [
-            ("outputnode.fmriprep_confounds_file", "fmriprep_confounds_file"),
             ("outputnode.preprocessed_bold", "preprocessed_bold"),
         ]),
     ])  # fmt:skip
@@ -253,7 +238,8 @@ def init_postprocess_cifti_wf(
     workflow.connect([
         (prepare_confounds_wf, denoise_bold_wf, [
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
-            ("outputnode.confounds_file", "inputnode.confounds_file"),
+            ("outputnode.confounds_tsv", "inputnode.confounds_tsv"),
+            ("outputnode.confounds_images", "inputnode.confounds_images"),
         ]),
         (denoise_bold_wf, outputnode, [
             ("outputnode.denoised_interpolated_bold", "denoised_interpolated_bold"),
@@ -319,9 +305,8 @@ def init_postprocess_cifti_wf(
         (prepare_confounds_wf, qc_report_wf, [
             ("outputnode.preprocessed_bold", "inputnode.preprocessed_bold"),
             ("outputnode.dummy_scans", "inputnode.dummy_scans"),
-            ("outputnode.fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
+            ("outputnode.motion_file", "inputnode.motion_file"),
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
-            ("outputnode.filtered_motion", "inputnode.filtered_motion"),
         ]),
         (denoise_bold_wf, qc_report_wf, [
             ("outputnode.denoised_interpolated_bold", "inputnode.denoised_interpolated_bold"),
@@ -333,12 +318,11 @@ def init_postprocess_cifti_wf(
         name_source=bold_file,
         source_metadata=run_data["bold_metadata"],
         exact_scans=exact_scans,
-        custom_confounds_file=custom_confounds_file,
     )
 
     workflow.connect([
         (inputnode, postproc_derivatives_wf, [
-            ("fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
+            ("motion_file", "inputnode.preproc_confounds_file"),
             ("atlas_files", "inputnode.atlas_files"),
         ]),
         (denoise_bold_wf, postproc_derivatives_wf, [
@@ -347,16 +331,16 @@ def init_postprocess_cifti_wf(
         ]),
         (qc_report_wf, postproc_derivatives_wf, [("outputnode.qc_file", "inputnode.qc_file")]),
         (prepare_confounds_wf, postproc_derivatives_wf, [
-            ("outputnode.confounds_file", "inputnode.confounds_file"),
+            ("outputnode.confounds_tsv", "inputnode.confounds_tsv"),
             ("outputnode.confounds_metadata", "inputnode.confounds_metadata"),
-            ("outputnode.filtered_motion", "inputnode.filtered_motion"),
+            ("outputnode.motion_file", "inputnode.motion_file"),
             ("outputnode.motion_metadata", "inputnode.motion_metadata"),
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
             ("outputnode.temporal_mask_metadata", "inputnode.temporal_mask_metadata"),
         ]),
         (reho_wf, postproc_derivatives_wf, [("outputnode.reho", "inputnode.reho")]),
         (postproc_derivatives_wf, outputnode, [
-            ("outputnode.filtered_motion", "filtered_motion"),
+            ("outputnode.motion_file", "motion_file"),
             ("outputnode.temporal_mask", "temporal_mask"),
             ("outputnode.denoised_bold", "denoised_bold"),
             ("outputnode.smoothed_denoised_bold", "smoothed_denoised_bold"),
diff --git a/xcp_d/workflows/bold/concatenation.py b/xcp_d/workflows/bold/concatenation.py
index b05b7d78c..cca941850 100644
--- a/xcp_d/workflows/bold/concatenation.py
+++ b/xcp_d/workflows/bold/concatenation.py
@@ -52,7 +52,7 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
         These are used as the bases for concatenated output filenames.
     preprocessed_bold : :obj:`list` of :obj:`str`
         The preprocessed BOLD files, after dummy volume removal.
-    %(filtered_motion)s
+    motion_file
         One list entry for each run.
     %(temporal_mask)s
         One list entry for each run.
@@ -75,7 +75,6 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
     workflow = Workflow(name=name)
 
     output_dir = config.execution.output_dir
-    motion_filter_type = config.workflow.motion_filter_type
     smoothing = config.workflow.smoothing
     file_format = config.workflow.file_format
     fd_thresh = config.workflow.fd_thresh
@@ -90,8 +89,7 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
             fields=[
                 "name_source",
                 "preprocessed_bold",
-                "fmriprep_confounds_file",
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "denoised_bold",
                 "denoised_interpolated_bold",
@@ -123,8 +121,7 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
     workflow.connect([
         (inputnode, filter_runs, [
             ("preprocessed_bold", "preprocessed_bold"),
-            ("fmriprep_confounds_file", "fmriprep_confounds_file"),
-            ("filtered_motion", "filtered_motion"),
+            ("motion_file", "motion_file"),
             ("temporal_mask", "temporal_mask"),
             ("denoised_bold", "denoised_bold"),
             ("denoised_interpolated_bold", "denoised_interpolated_bold"),
@@ -145,8 +142,7 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
     workflow.connect([
         (filter_runs, concatenate_inputs, [
             ("preprocessed_bold", "preprocessed_bold"),
-            ("fmriprep_confounds_file", "fmriprep_confounds_file"),
-            ("filtered_motion", "filtered_motion"),
+            ("motion_file", "motion_file"),
             ("temporal_mask", "temporal_mask"),
             ("denoised_bold", "denoised_bold"),
             ("denoised_interpolated_bold", "denoised_interpolated_bold"),
@@ -181,30 +177,26 @@ def init_concatenate_data_wf(TR, head_radius, name="concatenate_data_wf"):
             ("preprocessed_bold", "inputnode.preprocessed_bold"),
             ("denoised_interpolated_bold", "inputnode.denoised_interpolated_bold"),
             ("censored_denoised_bold", "inputnode.censored_denoised_bold"),
-            ("fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
-            ("filtered_motion", "inputnode.filtered_motion"),
+            ("motion_file", "inputnode.motion_file"),
             ("temporal_mask", "inputnode.temporal_mask"),
             ("run_index", "inputnode.run_index"),
         ]),
     ])  # fmt:skip
 
-    ds_filtered_motion = pe.Node(
+    ds_motion_file = pe.Node(
         DerivativesDataSink(
             dismiss_entities=["segmentation", "den", "res", "space", "cohort", "desc"],
-            desc="filtered" if motion_filter_type else None,
             suffix="motion",
             extension=".tsv",
         ),
-        name="ds_filtered_motion",
+        name="ds_motion_file",
         run_without_submitting=True,
         mem_gb=1,
     )
     workflow.connect([
-        (clean_name_source, ds_filtered_motion, [("name_source", "source_file")]),
-        (concatenate_inputs, ds_filtered_motion, [("filtered_motion", "in_file")]),
-        (filter_runs, ds_filtered_motion, [
-            (("filtered_motion", _make_xcpd_uri, output_dir), "Sources"),
-        ]),
+        (clean_name_source, ds_motion_file, [("name_source", "source_file")]),
+        (concatenate_inputs, ds_motion_file, [("motion_file", "in_file")]),
+        (filter_runs, ds_motion_file, [(("motion_file", _make_xcpd_uri, output_dir), "Sources")]),
     ])  # fmt:skip
 
     if fd_thresh > 0:
diff --git a/xcp_d/workflows/bold/connectivity.py b/xcp_d/workflows/bold/connectivity.py
index 04c5e0278..b51f2e087 100644
--- a/xcp_d/workflows/bold/connectivity.py
+++ b/xcp_d/workflows/bold/connectivity.py
@@ -271,7 +271,7 @@ def init_functional_connectivity_cifti_wf(mem_gb, exact_scans, name="connectivit
     parcellated_reho
     parcellated_alff
     """
-    from xcp_d.interfaces.censoring import ReduceCifti
+    from xcp_d.interfaces.censoring import Censor
     from xcp_d.interfaces.connectivity import CiftiToTSV, ConnectPlot
     from xcp_d.interfaces.plotting import PlotCiftiParcellation
     from xcp_d.interfaces.workbench import CiftiCorrelation
@@ -394,7 +394,7 @@ def init_functional_connectivity_cifti_wf(mem_gb, exact_scans, name="connectivit
         # If we want interpolated time series, the parcellated CIFTI will have interpolated values,
         # but the correlation matrices should only include low-motion volumes.
         remove_outliers = pe.MapNode(
-            ReduceCifti(column="framewise_displacement"),
+            Censor(column="framewise_displacement"),
             name="remove_outliers",
             iterfield=["in_file"],
         )
@@ -480,7 +480,7 @@ def init_functional_connectivity_cifti_wf(mem_gb, exact_scans, name="connectivit
 
         for i_exact_scan, exact_scan in enumerate(exact_scans):
             reduce_exact_bold = pe.MapNode(
-                ReduceCifti(column=f"exact_{exact_scan}"),
+                Censor(column=f"exact_{exact_scan}"),
                 name=f"reduce_bold_{exact_scan}volumes",
                 iterfield=["in_file"],
             )
diff --git a/xcp_d/workflows/bold/nifti.py b/xcp_d/workflows/bold/nifti.py
index bd77716ed..430ed84b9 100644
--- a/xcp_d/workflows/bold/nifti.py
+++ b/xcp_d/workflows/bold/nifti.py
@@ -10,7 +10,6 @@
 
 from xcp_d import config
 from xcp_d.interfaces.utils import ConvertTo32
-from xcp_d.utils.confounds import get_custom_confounds
 from xcp_d.utils.doc import fill_doc
 from xcp_d.utils.utils import _create_mem_gb
 from xcp_d.workflows.bold.connectivity import init_functional_connectivity_nifti_wf
@@ -104,7 +103,6 @@ def init_postprocess_nifti_wf(
     bold_mask
         bold_mask from fmriprep
         Loaded in this workflow.
-    %(custom_confounds_file)s
     %(template_to_anat_xfm)s
         Fed from the subject workflow.
     t1w
@@ -116,8 +114,8 @@ def init_postprocess_nifti_wf(
     anat_brainmask
         T1w brain mask in standard space, used for transforms in the QC report workflow.
         Fed from the subject workflow.
-    %(fmriprep_confounds_file)s
-    fmriprep_confounds_json
+    motion_file
+    motion_json
     %(dummy_scans)s
 
     Outputs
@@ -125,9 +123,8 @@ def init_postprocess_nifti_wf(
     %(name_source)s
     preprocessed_bold : :obj:`str`
         The preprocessed BOLD file, after dummy scan removal.
-    %(filtered_motion)s
     %(temporal_mask)s
-    %(fmriprep_confounds_file)s
+    motion_file
         After dummy scan removal.
     %(denoised_interpolated_bold)s
     %(smoothed_denoised_bold)s
@@ -144,7 +141,6 @@ def init_postprocess_nifti_wf(
     workflow = Workflow(name=name)
 
     bandpass_filter = config.workflow.bandpass_filter
-    custom_confounds_folder = config.execution.custom_confounds
     dummy_scans = config.workflow.dummy_scans
     despike = config.workflow.despike
     atlases = config.execution.atlases
@@ -156,20 +152,21 @@ def init_postprocess_nifti_wf(
             fields=[
                 "bold_file",
                 "boldref",
-                "bold_mask",
-                "custom_confounds_file",
-                "template_to_anat_xfm",
                 "t1w",
                 "t2w",
-                "anat_native",
-                "anat_brainmask",
-                "fmriprep_confounds_file",
-                "fmriprep_confounds_json",
+                "motion_file",
+                "motion_json",
+                "confounds_files",
                 "dummy_scans",
                 # if parcellation is performed
                 "atlases",
                 "atlas_files",
                 "atlas_labels_files",
+                # NIfTI only
+                "bold_mask",
+                "template_to_anat_xfm",
+                "anat_native",
+                "anat_brainmask",
             ],
         ),
         name="inputnode",
@@ -178,18 +175,13 @@ def init_postprocess_nifti_wf(
     inputnode.inputs.bold_file = bold_file
     inputnode.inputs.boldref = run_data["boldref"]
     inputnode.inputs.bold_mask = run_data["boldmask"]
-    inputnode.inputs.fmriprep_confounds_file = run_data["confounds"]
-    inputnode.inputs.fmriprep_confounds_json = run_data["confounds_json"]
+    inputnode.inputs.motion_file = run_data["motion_file"]
+    inputnode.inputs.motion_json = run_data["motion_json"]
+    inputnode.inputs.confounds_files = run_data["confounds"]
     inputnode.inputs.dummy_scans = dummy_scans
     inputnode.inputs.atlases = atlases
 
-    # Load custom confounds
-    # We need to run this function directly to access information in the confounds that is
-    # used for the boilerplate.
-    custom_confounds_file = get_custom_confounds(
-        custom_confounds_folder,
-        run_data["confounds"],
-    )
+    # Load confounds according to the config
 
     workflow.__desc__ = f"""\
 
@@ -203,8 +195,7 @@ def init_postprocess_nifti_wf(
             fields=[
                 "name_source",
                 "preprocessed_bold",
-                "fmriprep_confounds_file",
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "denoised_bold",
                 "denoised_interpolated_bold",
@@ -245,18 +236,17 @@ def init_postprocess_nifti_wf(
         TR=TR,
         exact_scans=exact_scans,
         head_radius=head_radius,
-        custom_confounds_file=custom_confounds_file,
     )
 
     workflow.connect([
         (inputnode, prepare_confounds_wf, [
             ("bold_file", "inputnode.name_source"),
-            ("fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
-            ("fmriprep_confounds_json", "inputnode.fmriprep_confounds_json"),
+            ("motion_file", "inputnode.motion_file"),
+            ("motion_json", "inputnode.motion_json"),
+            ("confounds_files", "inputnode.confounds_files"),
         ]),
         (downcast_data, prepare_confounds_wf, [("bold_file", "inputnode.preprocessed_bold")]),
         (prepare_confounds_wf, outputnode, [
-            ("outputnode.fmriprep_confounds_file", "fmriprep_confounds_file"),
             ("outputnode.preprocessed_bold", "preprocessed_bold"),
         ]),
     ])  # fmt:skip
@@ -267,7 +257,8 @@ def init_postprocess_nifti_wf(
         (downcast_data, denoise_bold_wf, [("bold_mask", "inputnode.mask")]),
         (prepare_confounds_wf, denoise_bold_wf, [
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
-            ("outputnode.confounds_file", "inputnode.confounds_file"),
+            ("outputnode.confounds_tsv", "inputnode.confounds_tsv"),
+            ("outputnode.confounds_images", "inputnode.confounds_images"),
         ]),
         (denoise_bold_wf, outputnode, [
             ("outputnode.denoised_interpolated_bold", "denoised_interpolated_bold"),
@@ -334,9 +325,8 @@ def init_postprocess_nifti_wf(
         (prepare_confounds_wf, qc_report_wf, [
             ("outputnode.preprocessed_bold", "inputnode.preprocessed_bold"),
             ("outputnode.dummy_scans", "inputnode.dummy_scans"),
-            ("outputnode.fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
+            ("outputnode.motion_file", "inputnode.motion_file"),
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
-            ("outputnode.filtered_motion", "inputnode.filtered_motion"),
         ]),
         (denoise_bold_wf, qc_report_wf, [
             ("outputnode.denoised_interpolated_bold", "inputnode.denoised_interpolated_bold"),
@@ -348,18 +338,17 @@ def init_postprocess_nifti_wf(
         name_source=bold_file,
         source_metadata=run_data["bold_metadata"],
         exact_scans=exact_scans,
-        custom_confounds_file=custom_confounds_file,
     )
 
     workflow.connect([
         (inputnode, postproc_derivatives_wf, [
-            ("fmriprep_confounds_file", "inputnode.fmriprep_confounds_file"),
+            ("motion_file", "inputnode.preproc_confounds_file"),
             ("atlas_files", "inputnode.atlas_files"),
         ]),
         (prepare_confounds_wf, postproc_derivatives_wf, [
-            ("outputnode.confounds_file", "inputnode.confounds_file"),
+            ("outputnode.confounds_tsv", "inputnode.confounds_tsv"),
             ("outputnode.confounds_metadata", "inputnode.confounds_metadata"),
-            ("outputnode.filtered_motion", "inputnode.filtered_motion"),
+            ("outputnode.motion_file", "inputnode.motion_file"),
             ("outputnode.motion_metadata", "inputnode.motion_metadata"),
             ("outputnode.temporal_mask", "inputnode.temporal_mask"),
             ("outputnode.temporal_mask_metadata", "inputnode.temporal_mask_metadata"),
@@ -371,7 +360,7 @@ def init_postprocess_nifti_wf(
         (qc_report_wf, postproc_derivatives_wf, [("outputnode.qc_file", "inputnode.qc_file")]),
         (reho_wf, postproc_derivatives_wf, [("outputnode.reho", "inputnode.reho")]),
         (postproc_derivatives_wf, outputnode, [
-            ("outputnode.filtered_motion", "filtered_motion"),
+            ("outputnode.motion_file", "motion_file"),
             ("outputnode.temporal_mask", "temporal_mask"),
             ("outputnode.denoised_bold", "denoised_bold"),
             ("outputnode.smoothed_denoised_bold", "smoothed_denoised_bold"),
diff --git a/xcp_d/workflows/bold/outputs.py b/xcp_d/workflows/bold/outputs.py
index 4ce3b3476..4be169810 100644
--- a/xcp_d/workflows/bold/outputs.py
+++ b/xcp_d/workflows/bold/outputs.py
@@ -10,7 +10,6 @@
 from xcp_d.interfaces.bids import DerivativesDataSink
 from xcp_d.utils.bids import (
     _make_atlas_uri,
-    _make_custom_uri,
     _make_preproc_uri,
     _make_xcpd_uri,
     get_entity,
@@ -24,7 +23,6 @@ def init_postproc_derivatives_wf(
     name_source,
     source_metadata,
     exact_scans,
-    custom_confounds_file,
     name="postproc_derivatives_wf",
 ):
     """Write out the xcp_d derivatives in BIDS format.
@@ -43,7 +41,6 @@ def init_postproc_derivatives_wf(
                     name_source="/path/to/file.nii.gz",
                     source_metadata={},
                     exact_scans=[],
-                    custom_confounds_file=None,
                     name="postproc_derivatives_wf",
                 )
 
@@ -53,8 +50,6 @@ def init_postproc_derivatives_wf(
         bold or cifti files
     source_metadata : :obj:`dict`
     %(exact_scans)s
-    custom_confounds_file
-        Only used for Sources metadata.
     %(name)s
         Default is "connectivity_wf".
 
@@ -78,9 +73,9 @@ def init_postproc_derivatives_wf(
         smoothed alff
     reho
     parcellated_reho
-    confounds_file
+    confounds_tsv
     confounds_metadata
-    %(filtered_motion)s
+    motion_file
     motion_metadata
     %(temporal_mask)s
     temporal_mask_metadata
@@ -94,9 +89,7 @@ def init_postproc_derivatives_wf(
     high_pass = config.workflow.high_pass
     bpf_order = config.workflow.bpf_order
     fd_thresh = config.workflow.fd_thresh
-    motion_filter_type = config.workflow.motion_filter_type
     smoothing = config.workflow.smoothing
-    params = config.workflow.params
     atlases = config.execution.atlases
     file_format = config.workflow.file_format
     output_dir = config.execution.output_dir
@@ -105,10 +98,10 @@ def init_postproc_derivatives_wf(
         niu.IdentityInterface(
             fields=[
                 # preprocessing files to use as sources
-                "fmriprep_confounds_file",
+                "preproc_confounds_file",
                 # postprocessed outputs
                 "atlas_files",  # for Sources
-                "confounds_file",
+                "confounds_tsv",
                 "confounds_metadata",
                 "coverage",
                 "timeseries",
@@ -122,7 +115,7 @@ def init_postproc_derivatives_wf(
                 "smoothed_alff",
                 "reho",
                 "parcellated_reho",
-                "filtered_motion",
+                "motion_file",
                 "motion_metadata",
                 "temporal_mask",
                 "temporal_mask_metadata",
@@ -142,7 +135,7 @@ def init_postproc_derivatives_wf(
     outputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "denoised_bold",
                 "censored_denoised_bold",
@@ -156,7 +149,6 @@ def init_postproc_derivatives_wf(
 
     # Create dictionary of basic information
     cleaned_data_dictionary = {
-        "NuisanceParameters": params,
         **source_metadata,
     }
     software_filters = None
@@ -184,29 +176,34 @@ def init_postproc_derivatives_wf(
 
     preproc_bold_src = _make_preproc_uri(name_source, fmri_dir)
 
-    ds_filtered_motion = pe.Node(
+    ds_motion = pe.Node(
         DerivativesDataSink(
             source_file=name_source,
             dismiss_entities=["segmentation", "den", "res", "space", "cohort", "desc"],
-            desc="filtered" if motion_filter_type else None,
             suffix="motion",
             extension=".tsv",
         ),
-        name="ds_filtered_motion",
+        name="ds_motion",
         run_without_submitting=True,
         mem_gb=1,
     )
     workflow.connect([
-        (inputnode, ds_filtered_motion, [
+        (inputnode, ds_motion, [
             ("motion_metadata", "meta_dict"),
-            ("filtered_motion", "in_file"),
-            (("fmriprep_confounds_file", _make_preproc_uri, fmri_dir), "Sources"),
+            ("motion_file", "in_file"),
+            (("preproc_confounds_file", _make_preproc_uri, fmri_dir), "Sources"),
         ]),
-        (ds_filtered_motion, outputnode, [("out_file", "filtered_motion")]),
+        (ds_motion, outputnode, [("out_file", "motion_file")]),
     ])  # fmt:skip
 
     merge_dense_src = pe.Node(
-        niu.Merge(numinputs=(1 + (1 if fd_thresh > 0 else 0) + (1 if params != "none" else 0))),
+        niu.Merge(
+            numinputs=(
+                1
+                + (1 if fd_thresh > 0 else 0)
+                + (1 if config.execution.confounds_config != "none" else 0)
+            ),
+        ),
         name="merge_dense_src",
         run_without_submitting=True,
         mem_gb=1,
@@ -232,25 +229,23 @@ def init_postproc_derivatives_wf(
                 ("temporal_mask_metadata", "meta_dict"),
                 ("temporal_mask", "in_file"),
             ]),
-            (ds_filtered_motion, ds_temporal_mask, [
-                (("out_file", _make_xcpd_uri, output_dir), "Sources"),
-            ]),
+            (ds_motion, ds_temporal_mask, [(("out_file", _make_xcpd_uri, output_dir), "Sources")]),
             (ds_temporal_mask, outputnode, [("out_file", "temporal_mask")]),
             (ds_temporal_mask, merge_dense_src, [
                 (("out_file", _make_xcpd_uri, output_dir), "in2"),
             ]),
         ])  # fmt:skip
 
-    if params != "none":
+    if config.execution.confounds_config is not None:
+        # XXX: I need to combine collected confounds files as Sources here.
+        # Not just the preproc_confounds_file.
         confounds_src = pe.Node(
-            niu.Merge(
-                numinputs=(1 + (1 if fd_thresh > 0 else 0) + (1 if custom_confounds_file else 0))
-            ),
+            niu.Merge(numinputs=(1 + (1 if fd_thresh > 0 else 0))),
             name="confounds_src",
             run_without_submitting=True,
             mem_gb=1,
         )
-        workflow.connect([(inputnode, confounds_src, [("fmriprep_confounds_file", "in1")])])
+        workflow.connect([(inputnode, confounds_src, [("preproc_confounds_file", "in1")])])
         if fd_thresh > 0:
             workflow.connect([
                 (ds_temporal_mask, confounds_src, [
@@ -258,12 +253,6 @@ def init_postproc_derivatives_wf(
                 ]),
             ])  # fmt:skip
 
-            if custom_confounds_file:
-                confounds_src.inputs.in3 = _make_custom_uri(custom_confounds_file)
-
-        elif custom_confounds_file:
-            confounds_src.inputs.in2 = _make_custom_uri(custom_confounds_file)
-
         ds_confounds = pe.Node(
             DerivativesDataSink(
                 source_file=name_source,
@@ -277,7 +266,7 @@ def init_postproc_derivatives_wf(
         )
         workflow.connect([
             (inputnode, ds_confounds, [
-                ("confounds_file", "in_file"),
+                ("confounds_tsv", "in_file"),
                 ("confounds_metadata", "meta_dict"),
             ]),
             (confounds_src, ds_confounds, [("out", "Sources")]),
diff --git a/xcp_d/workflows/bold/plotting.py b/xcp_d/workflows/bold/plotting.py
index 79b2c7c2b..b462e156d 100644
--- a/xcp_d/workflows/bold/plotting.py
+++ b/xcp_d/workflows/bold/plotting.py
@@ -76,9 +76,8 @@ def init_qc_report_wf(
     %(template_to_anat_xfm)s
         Only used with non-CIFTI data.
     %(dummy_scans)s
-    %(fmriprep_confounds_file)s
+    motion_file
     %(temporal_mask)s
-    %(filtered_motion)s
 
     Outputs
     -------
@@ -94,8 +93,7 @@ def init_qc_report_wf(
                 "denoised_interpolated_bold",
                 "censored_denoised_bold",
                 "dummy_scans",
-                "fmriprep_confounds_file",
-                "filtered_motion",
+                "motion_file",
                 "temporal_mask",
                 "run_index",  # will only be set for concatenated data
                 # nifti-only inputs
@@ -293,7 +291,7 @@ def init_qc_report_wf(
                 ("name_source", "name_source"),
                 ("preprocessed_bold", "bold_file"),
                 ("censored_denoised_bold", "cleaned_file"),
-                ("fmriprep_confounds_file", "fmriprep_confounds_file"),
+                ("motion_file", "motion_file"),
                 ("temporal_mask", "temporal_mask"),
                 ("dummy_scans", "dummy_scans"),
             ]),
@@ -335,7 +333,7 @@ def init_qc_report_wf(
             (inputnode, make_qc_plots_nipreps, [
                 ("preprocessed_bold", "bold_file"),
                 ("censored_denoised_bold", "cleaned_file"),
-                ("fmriprep_confounds_file", "fmriprep_confounds_file"),
+                ("motion_file", "motion_file"),
                 ("temporal_mask", "temporal_mask"),
             ]),
         ])  # fmt:skip
@@ -398,7 +396,7 @@ def init_qc_report_wf(
             name="make_abcc_qc",
             mem_gb=2,
         )
-        workflow.connect([(inputnode, make_abcc_qc, [("filtered_motion", "filtered_motion")])])
+        workflow.connect([(inputnode, make_abcc_qc, [("motion_file", "motion_file")])])
 
         ds_abcc_qc = pe.Node(
             DerivativesDataSink(
@@ -417,7 +415,7 @@ def init_qc_report_wf(
 
         # Generate preprocessing and postprocessing carpet plots.
         make_qc_plots_es = pe.Node(
-            QCPlotsES(TR=TR, standardize=config.workflow.params == "none"),
+            QCPlotsES(TR=TR, standardize=config.execution.confounds_config is None),
             name="make_qc_plots_es",
             mem_gb=2,
         )
@@ -425,7 +423,7 @@ def init_qc_report_wf(
             (inputnode, make_qc_plots_es, [
                 ("preprocessed_bold", "preprocessed_bold"),
                 ("denoised_interpolated_bold", "denoised_interpolated_bold"),
-                ("filtered_motion", "filtered_motion"),
+                ("motion_file", "motion_file"),
                 ("temporal_mask", "temporal_mask"),
                 ("run_index", "run_index"),
             ]),
diff --git a/xcp_d/workflows/bold/postprocessing.py b/xcp_d/workflows/bold/postprocessing.py
index 87b7a3917..7785850a8 100644
--- a/xcp_d/workflows/bold/postprocessing.py
+++ b/xcp_d/workflows/bold/postprocessing.py
@@ -2,6 +2,7 @@
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """Workflows for post-processing BOLD data."""
 
+import yaml
 from nipype.interfaces import utility as niu
 from nipype.pipeline import engine as pe
 from niworkflows.engine.workflows import LiterateWorkflow as Workflow
@@ -13,6 +14,7 @@
 from xcp_d.interfaces.censoring import (
     Censor,
     GenerateConfounds,
+    ProcessMotion,
     RandomCensor,
     RemoveDummyVolumes,
 )
@@ -35,7 +37,6 @@ def init_prepare_confounds_wf(
     TR,
     exact_scans,
     head_radius,
-    custom_confounds_file,
     name="prepare_confounds_wf",
 ):
     """Prepare confounds.
@@ -57,7 +58,6 @@ def init_prepare_confounds_wf(
                     TR=0.8,
                     exact_scans=[],
                     head_radius=70,
-                    custom_confounds_file=None,
                     name="prepare_confounds_wf",
                 )
 
@@ -67,7 +67,6 @@ def init_prepare_confounds_wf(
     %(exact_scans)s
     %(head_radius)s
         This will already be estimated before this workflow.
-    %(custom_confounds_file)s
     %(name)s
         Default is "prepare_confounds_wf".
 
@@ -75,32 +74,32 @@ def init_prepare_confounds_wf(
     ------
     %(name_source)s
     preprocessed_bold : :obj:`str`
-    %(fmriprep_confounds_file)s
-    fmriprep_confounds_json : :obj:`str`
+    motion_file : :obj:`str`
+        The motion parameters estimated by fMRIPrep.
+    motion_json : :obj:`str`
         JSON file associated with the fMRIPrep confounds TSV.
-    %(custom_confounds_file)s
+    confounds_files : :obj:`dict`
     %(dummy_scans)s
         Set from the parameter.
 
     Outputs
     -------
     preprocessed_bold : :obj:`str`
-    %(fmriprep_confounds_file)s
-    confounds_file : :obj:`str`
+    motion_file
+    confounds_tsv : :obj:`str`
         The selected confounds, potentially including custom confounds, after dummy scan removal.
+    confounds_images : :obj:`list` of :obj:`str`
     confounds_metadata : :obj:`dict`
     %(dummy_scans)s
         If originally set to "auto", this output will have the actual number of dummy volumes.
-    %(filtered_motion)s
+    motion_file
     motion_metadata : :obj:`dict`
     %(temporal_mask)s
     temporal_mask_metadata : :obj:`dict`
     """
     workflow = Workflow(name=name)
 
-    params = config.workflow.params
     dummy_scans = config.workflow.dummy_scans
-    random_seed = config.seeds.master
     motion_filter_type = config.workflow.motion_filter_type
     band_stop_min = config.workflow.band_stop_min
     band_stop_max = config.workflow.band_stop_max
@@ -129,23 +128,32 @@ def init_prepare_confounds_wf(
         motion_filter_order=motion_filter_order,
         band_stop_min=band_stop_min,
         band_stop_max=band_stop_max,
-        head_radius=head_radius,
         TR=TR,
     )
 
     if (fd_thresh > 0) or exact_scans:
         censoring_description = describe_censoring(
             motion_filter_type=motion_filter_type,
+            head_radius=head_radius,
             fd_thresh=fd_thresh,
             exact_scans=exact_scans,
         )
     else:
         censoring_description = ""
 
+    if config.execution.confounds_config is None:
+        confounds_config = None
+    else:
+        confounds_config = yaml.safe_load(config.execution.confounds_config.read_text())
+
     confounds_description = describe_regression(
-        params=params,
-        custom_confounds_file=custom_confounds_file,
+        confounds_config=confounds_config,
         motion_filter_type=motion_filter_type,
+        motion_filter_order=motion_filter_order,
+        band_stop_min=band_stop_min,
+        band_stop_max=band_stop_max,
+        TR=TR,
+        fd_thresh=fd_thresh,
     )
 
     workflow.__desc__ = (
@@ -157,37 +165,36 @@ def init_prepare_confounds_wf(
             fields=[
                 "name_source",
                 "preprocessed_bold",
-                "fmriprep_confounds_file",
-                "fmriprep_confounds_json",
-                "custom_confounds_file",
                 "dummy_scans",
+                "motion_file",
+                "motion_json",
+                "confounds_files",
             ],
         ),
         name="inputnode",
     )
     inputnode.inputs.dummy_scans = dummy_scans
-    inputnode.inputs.custom_confounds_file = custom_confounds_file
 
     outputnode = pe.Node(
         niu.IdentityInterface(
             fields=[
                 "preprocessed_bold",
-                "fmriprep_confounds_file",  # used to calculate motion in concatenation workflow
-                "confounds_file",
-                "confounds_metadata",
                 "dummy_scans",
-                "filtered_motion",
+                "motion_file",
                 "motion_metadata",
                 "temporal_mask",
                 "temporal_mask_metadata",
+                "confounds_tsv",
+                "confounds_images",
+                "confounds_metadata",
             ],
         ),
         name="outputnode",
     )
 
-    generate_confounds = pe.Node(
-        GenerateConfounds(
-            params=params,
+    # Filter motion parameters and calculate FD for censoring
+    process_motion = pe.Node(
+        ProcessMotion(
             TR=TR,
             band_stop_min=band_stop_min,
             band_stop_max=band_stop_max,
@@ -196,32 +203,54 @@ def init_prepare_confounds_wf(
             fd_thresh=fd_thresh,
             head_radius=head_radius,
         ),
-        name="generate_confounds",
-        mem_gb=2,
+        name="process_motion",
+        mem_gb=1,
+        n_procs=1,
     )
 
-    # Load and filter confounds
     workflow.connect([
-        (inputnode, generate_confounds, [
-            ("name_source", "in_file"),
-            ("fmriprep_confounds_file", "fmriprep_confounds_file"),
-            ("fmriprep_confounds_json", "fmriprep_confounds_json"),
-            ("custom_confounds_file", "custom_confounds_file"),
-        ]),
-        (generate_confounds, outputnode, [
-            ("motion_metadata", "motion_metadata"),
-            ("confounds_metadata", "confounds_metadata"),
+        (inputnode, process_motion, [
+            ("motion_file", "motion_file"),
+            ("motion_json", "motion_json"),
         ]),
+        (process_motion, outputnode, [("motion_metadata", "motion_metadata")]),
     ])  # fmt:skip
 
+    if config.execution.confounds_config is not None:
+        confounds_config = yaml.safe_load(config.execution.confounds_config.read_text())
+
+        generate_confounds = pe.Node(
+            GenerateConfounds(
+                confounds_config=confounds_config,
+                TR=TR,
+                dataset_links=config.execution.dataset_links,
+                out_dir=str(config.execution.output_dir),
+                band_stop_min=band_stop_min,
+                band_stop_max=band_stop_max,
+                motion_filter_type=motion_filter_type,
+                motion_filter_order=motion_filter_order,
+            ),
+            name="generate_confounds",
+            mem_gb=2,
+        )
+
+        # Load and filter confounds
+        workflow.connect([
+            (inputnode, generate_confounds, [
+                ("name_source", "in_file"),
+                ("confounds_files", "confounds_files"),
+            ]),
+            (generate_confounds, outputnode, [("confounds_metadata", "confounds_metadata")]),
+        ])  # fmt:skip
+
     # A buffer node to hold either the original files or the files with the first N vols removed.
     dummy_scan_buffer = pe.Node(
         niu.IdentityInterface(
             fields=[
                 "preprocessed_bold",
                 "dummy_scans",
-                "fmriprep_confounds_file",
-                "confounds_file",
+                "confounds_tsv",
+                "confounds_images",
                 "motion_file",
                 "temporal_mask",
             ]
@@ -241,57 +270,71 @@ def init_prepare_confounds_wf(
                 ("preprocessed_bold", "bold_file"),
                 ("dummy_scans", "dummy_scans"),
             ]),
-            (generate_confounds, remove_dummy_scans, [
-                ("confounds_file", "confounds_file"),
+            (process_motion, remove_dummy_scans, [
                 ("motion_file", "motion_file"),
                 ("temporal_mask", "temporal_mask"),
-                # fMRIPrep confounds file is needed for filtered motion.
-                # The selected confounds are not guaranteed to include motion params.
-                ("filtered_confounds_file", "fmriprep_confounds_file"),
             ]),
             (remove_dummy_scans, dummy_scan_buffer, [
                 ("bold_file_dropped_TR", "preprocessed_bold"),
-                ("fmriprep_confounds_file_dropped_TR", "fmriprep_confounds_file"),
-                ("confounds_file_dropped_TR", "confounds_file"),
+                ("confounds_tsv_dropped_TR", "confounds_tsv"),
+                ("confounds_images_dropped_TR", "confounds_images"),
                 ("motion_file_dropped_TR", "motion_file"),
                 ("temporal_mask_dropped_TR", "temporal_mask"),
                 ("dummy_scans", "dummy_scans"),
             ]),
         ])  # fmt:skip
+
+        if config.execution.confounds_config is not None:
+            workflow.connect([
+                (generate_confounds, remove_dummy_scans, [
+                    ("confounds_tsv", "confounds_tsv"),
+                    ("confounds_images", "confounds_images"),
+                ]),
+            ])  # fmt:skip
     else:
         workflow.connect([
             (inputnode, dummy_scan_buffer, [
                 ("dummy_scans", "dummy_scans"),
                 ("preprocessed_bold", "preprocessed_bold"),
             ]),
-            (generate_confounds, dummy_scan_buffer, [
-                ("confounds_file", "confounds_file"),
+            (process_motion, dummy_scan_buffer, [
                 ("motion_file", "motion_file"),
                 ("temporal_mask", "temporal_mask"),
-                # fMRIPrep confounds file is needed for filtered motion.
-                # The selected confounds are not guaranteed to include motion params.
-                ("filtered_confounds_file", "fmriprep_confounds_file"),
             ]),
         ])  # fmt:skip
 
+        if config.execution.confounds_config is not None:
+            workflow.connect([
+                (generate_confounds, dummy_scan_buffer, [
+                    ("confounds_tsv", "confounds_tsv"),
+                    ("confounds_images", "confounds_images"),
+                ]),
+            ])  # fmt:skip
+
     workflow.connect([
         (dummy_scan_buffer, outputnode, [
             ("preprocessed_bold", "preprocessed_bold"),
-            ("fmriprep_confounds_file", "fmriprep_confounds_file"),
-            ("confounds_file", "confounds_file"),
-            ("motion_file", "filtered_motion"),
             ("dummy_scans", "dummy_scans"),
+            ("motion_file", "motion_file"),
         ]),
     ])  # fmt:skip
 
+    if config.execution.confounds_config is not None:
+        workflow.connect([
+            (dummy_scan_buffer, outputnode, [
+                ("confounds_tsv", "confounds_tsv"),
+                ("confounds_images", "confounds_images"),
+            ]),
+        ])  # fmt:skip
+
     if config.workflow.dcan_correlation_lengths:
         random_censor = pe.Node(
-            RandomCensor(exact_scans=exact_scans, random_seed=random_seed),
+            RandomCensor(exact_scans=exact_scans, random_seed=config.seeds.master),
             name="random_censor",
         )
 
         workflow.connect([
-            (generate_confounds, random_censor, [
+            (process_motion, random_censor, [
                 ("temporal_mask_metadata", "temporal_mask_metadata"),
             ]),
             (dummy_scan_buffer, random_censor, [("temporal_mask", "temporal_mask")]),
@@ -302,13 +345,11 @@ def init_prepare_confounds_wf(
         ])  # fmt:skip
     else:
         workflow.connect([
-            (generate_confounds, outputnode, [
-                ("temporal_mask_metadata", "temporal_mask_metadata"),
-            ]),
+            (process_motion, outputnode, [("temporal_mask_metadata", "temporal_mask_metadata")]),
             (dummy_scan_buffer, outputnode, [("temporal_mask", "temporal_mask")]),
         ])  # fmt:skip
 
-    if params != "none":
+    if config.execution.confounds_config is not None:
         plot_design_matrix = pe.Node(
             niu.Function(
                 input_names=["design_matrix", "temporal_mask"],
@@ -319,7 +360,7 @@ def init_prepare_confounds_wf(
         )
 
         workflow.connect([
-            (dummy_scan_buffer, plot_design_matrix, [("confounds_file", "design_matrix")]),
+            (dummy_scan_buffer, plot_design_matrix, [("confounds_tsv", "design_matrix")]),
             (outputnode, plot_design_matrix, [("temporal_mask", "temporal_mask")]),
         ])  # fmt:skip
 
@@ -351,8 +392,7 @@ def init_prepare_confounds_wf(
 
     workflow.connect([
         # use the full version of the confounds, for dummy scans in the figure
-        (inputnode, censor_report, [("fmriprep_confounds_file", "fmriprep_confounds_file")]),
-        (generate_confounds, censor_report, [("motion_file", "filtered_motion")]),
+        (process_motion, censor_report, [("motion_file", "motion_file")]),
         (dummy_scan_buffer, censor_report, [("dummy_scans", "dummy_scans")]),
         (outputnode, censor_report, [("temporal_mask", "temporal_mask")]),
     ])  # fmt:skip
@@ -579,8 +619,9 @@ def init_denoise_bold_wf(TR, mem_gb, name="denoise_bold_wf"):
             fields=[
                 "preprocessed_bold",
                 "temporal_mask",
+                "confounds_tsv",
+                "confounds_images",
                 "mask",  # only used for NIFTIs
-                "confounds_file",
             ],
         ),
         name="inputnode",
@@ -613,7 +654,8 @@ def init_denoise_bold_wf(TR, mem_gb, name="denoise_bold_wf"):
     workflow.connect([
         (inputnode, regress_and_filter_bold, [
             ("preprocessed_bold", "preprocessed_bold"),
-            ("confounds_file", "confounds_file"),
+            ("confounds_tsv", "confounds_tsv"),
+            ("confounds_images", "confounds_images"),
             ("temporal_mask", "temporal_mask"),
         ]),
         (regress_and_filter_bold, outputnode, [
@@ -624,7 +666,7 @@ def init_denoise_bold_wf(TR, mem_gb, name="denoise_bold_wf"):
         workflow.connect([(inputnode, regress_and_filter_bold, [("mask", "mask")])])
 
     censor_interpolated_data = pe.Node(
-        Censor(),
+        Censor(column="framewise_displacement"),
         name="censor_interpolated_data",
         mem_gb=mem_gb["resampled"],
     )
@@ -634,9 +676,7 @@ def init_denoise_bold_wf(TR, mem_gb, name="denoise_bold_wf"):
         (regress_and_filter_bold, censor_interpolated_data, [
             ("denoised_interpolated_bold", "in_file"),
         ]),
-        (censor_interpolated_data, outputnode, [
-            ("censored_denoised_bold", "censored_denoised_bold"),
-        ]),
+        (censor_interpolated_data, outputnode, [("out_file", "censored_denoised_bold")]),
     ])  # fmt:skip
 
     denoised_bold_buffer = pe.Node(
@@ -651,9 +691,7 @@ def init_denoise_bold_wf(TR, mem_gb, name="denoise_bold_wf"):
         ])  # fmt:skip
     else:
         workflow.connect([
-            (censor_interpolated_data, denoised_bold_buffer, [
-                ("censored_denoised_bold", "denoised_bold"),
-            ]),
+            (censor_interpolated_data, denoised_bold_buffer, [("out_file", "denoised_bold")]),
         ])  # fmt:skip
 
     workflow.connect([(denoised_bold_buffer, outputnode, [("denoised_bold", "denoised_bold")])])