diff --git a/.github/workflows/meta.yml b/.github/workflows/meta.yml
new file mode 100644
index 0000000000..5deae0c166
--- /dev/null
+++ b/.github/workflows/meta.yml
@@ -0,0 +1,310 @@
+name: metapackage-tests
+
+on:
+  push:
+    paths:
+      - 'src/*meta*.f90'  # On push, only launch job if something has changed in the metapackages
+      - 'src/fpm/*meta*.f90'
+      - 'src/fpm/manifest/*meta*.f90'
+      - 'src/ci/meta_tests.sh'
+      - 'src/.github/workflows/meta.yml'
+  pull_request:
+  release:
+    types: [published]
+
+env:
+  CI: "ON" # We can detect this in the build system and other vendors implement it
+  HOMEBREW_NO_ANALYTICS: 1 # Make Homebrew installation a little quicker
+  HOMEBREW_NO_AUTO_UPDATE: 1
+  HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: 1
+  HOMEBREW_NO_GITHUB_API: 1
+  HOMEBREW_NO_INSTALL_CLEANUP: 1
+  HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: 1
+
+jobs:
+
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            mpi: intel
+          - os: ubuntu-latest
+            mpi: openmpi
+          - os: ubuntu-latest
+            mpi: mpich
+          - os: windows-latest
+            mpi: msmpi
+          - os: macos-latest
+            mpi: openmpi
+          - os: macos-latest
+            mpi: mpich
+
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v1
+
+    - name: (Ubuntu) setup gcc version
+      if: contains(matrix.os,'ubuntu')
+      run: |
+        echo "GCC_V=10" >> $GITHUB_ENV
+
+    - name: (macOS) setup gcc version
+      if: contains(matrix.os,'macos')
+      run: |
+        echo "GCC_V=13" >> $GITHUB_ENV
+
+    - name: (Windows) Install MSYS2
+      uses: msys2/setup-msys2@v2
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+      with:
+        msystem: MINGW64
+        update: true
+        install: >-
+          git
+          base-devel
+          wget
+          unzip
+          curl
+
+    - name: (Windows) Setup VS Build environment
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'intel')
+      uses: seanmiddleditch/gha-setup-vsdevenv@master
+
+    - name: (Windows) Retrieve Intel toolchain
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'intel')
+      shell: pwsh
+      working-directory: C:\TEMP
+      run: |
+        curl.exe --output webimage.exe --url https://registrationcenter-download.intel.com/akdlm/irc_nas/19085/w_HPCKit_p_2023.0.0.25931_offline.exe --retry 5 --retry-delay 5
+        Start-Process -FilePath "webimage.exe" -ArgumentList "-s -x -f oneAPI --log extract.log" -Wait
+        Remove-Item "webimage.exe" -Force
+        Start-Process -FilePath "oneAPI\bootstrapper.exe" -ArgumentList "-s --action install --eula=accept --components=""intel.oneapi.win.cpp-compiler:intel.oneapi.win.ifort-compiler:intel.oneapi.win.mpi.devel"" -p=NEED_VS2017_INTEGRATION=0 -p=NEED_VS2019_INTEGRATION=0 -p=NEED_VS2022_INTEGRATION=0 --log-dir=." -Wait
+        Remove-Item "oneAPI" -Force -Recurse
+
+    - name: (Ubuntu) Install gfortran
+      if: contains(matrix.os,'ubuntu') && (!contains(matrix.mpi,'intel'))
+      run: |
+        sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-${GCC_V} 100 \
+        --slave /usr/bin/gfortran gfortran /usr/bin/gfortran-${GCC_V} \
+        --slave /usr/bin/gcov gcov /usr/bin/gcov-${GCC_V}
+
+    - name: (Ubuntu) Install OpenMPI
+      if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'openmpi')
+      run: |
+        sudo apt install -y -q openmpi-bin libopenmpi-dev
+
+    - name: (Ubuntu) Install MPICH
+      if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'mpich')
+      run: |
+        sudo apt install -y -q mpich
+
+    - name: (Ubuntu) Retrieve Intel toolchain
+      if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'intel')
+      timeout-minutes: 1
+      run: |
+        wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB
+        sudo apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB
+        rm GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB
+        echo "deb https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
+        sudo apt-get update
+
+    - name: (Ubuntu) Install Intel oneAPI
+      if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'intel')
+      timeout-minutes: 5
+      run: sudo apt-get install intel-oneapi-compiler-fortran intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic intel-oneapi-mpi intel-oneapi-mpi-devel intel-oneapi-mkl ninja-build
+
+    - name: (Ubuntu) Setup Intel oneAPI environment
+      if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'intel')
+      run: |
+        source /opt/intel/oneapi/setvars.sh
+        printenv >> $GITHUB_ENV
+
+    - name: (Windows) Put MSYS2_MinGW64 on PATH
+      if: contains(matrix.os,'windows') && (!contains(matrix.mpi,'intel'))
+      # there is not yet an environment variable for this path from msys2/setup-msys2
+      run: echo "${{ runner.temp }}/msys64/mingw64/bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+    - name: (Windows) download MS-MPI setup (SDK is from MSYS2)
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+        #     run: curl -L -O https://github.com/microsoft/Microsoft-MPI/releases/download/v10.1.2/msmpisetup.exe 10.1.1
+      run: curl -L -O https://download.microsoft.com/download/a/5/2/a5207ca5-1203-491a-8fb8-906fd68ae623/msmpisetup.exe # 10.1.2
+
+    - name: (Windows) Install mpiexec.exe (-force needed to bypass GUI on headless)
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+      run: .\msmpisetup.exe -unattend -force
+
+    - name: (Windows) test that mpiexec.exe exists
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+      # can't use MSMPI_BIN as Actions doesn't update PATH from msmpisetup.exe
+      run: Test-Path "C:\Program Files\Microsoft MPI\Bin\mpiexec.exe" -PathType leaf
+
+    - name: (Windows) test that OneAPI is installed
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'intel')
+      run: |
+        Test-Path -Path "C:\Program Files (x86)\Intel\oneAPI\setvars.bat" -PathType leaf
+        Test-Path -Path "C:\Program Files (x86)\Intel\oneAPI\compiler\latest\env\vars.bat" -PathType leaf
+
+    - name: (Windows) put MSMPI_BIN on PATH (where mpiexec is)
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+      run: |
+        echo "C:\Program Files\Microsoft MPI\Bin\" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+        echo "MSMPI_BIN=C:\Program Files\Microsoft MPI\Bin\" | Out-File -FilePath $env:GITHUB_ENV -Append
+
+    - name: (Windows) load OneAPI environment variables
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'intel')
+      shell: cmd
+      run: |
+        "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
+        "C:\Program Files (x86)\Intel\oneAPI\compiler\latest\env\vars.bat"
+
+    - name: (Windows) Install MSYS2 msmpi package
+      if: contains(matrix.os,'windows') && contains(matrix.mpi,'msmpi')
+      shell: msys2 {0}
+      run: pacman --noconfirm -S mingw-w64-x86_64-msmpi
+
+    - name: (macOS) Set up Homebrew
+      if: contains(matrix.os,'macos')
+      id: set-up-homebrew
+      uses: Homebrew/actions/setup-homebrew@master
+
+    - name: (macOS) Install Homebrew gfortran
+      if: contains(matrix.os, 'macos')
+      run: |
+        # Only install gcc if not already available
+        which gfortran-${{ env.GCC_V }} || brew install gcc@${{ env.GCC_V }}
+        which gfortran-${{ env.GCC_V }}
+        which gfortran || ln -s /usr/local/bin/gfortran-${{ env.GCC_V }} /usr/local/bin/gfortran
+        # Backport gfortran shared libraries to version 10 folder. This is necessary because all macOS releases of fpm
+        # have these paths hardcoded in the executable (no PIC?). Current bootstrap version 0.8.0 has gcc-10
+        mkdir /usr/local/opt/gcc@10
+        mkdir /usr/local/opt/gcc@10/lib
+        mkdir /usr/local/opt/gcc@10/lib/gcc
+        mkdir /usr/local/opt/gcc@10/lib/gcc/10
+        mkdir /usr/local/lib/gcc/10
+        ln -fs /usr/local/opt/gcc@${{ env.GCC_V }}/lib/gcc/${{ env.GCC_V }}/libquadmath.0.dylib /usr/local/opt/gcc@10/lib/gcc/10/libquadmath.0.dylib
+        ln -fs /usr/local/opt/gcc@${{ env.GCC_V }}/lib/gcc/${{ env.GCC_V }}/libgfortran.5.dylib /usr/local/opt/gcc@10/lib/gcc/10/libgfortran.5.dylib
+        # Newer gcc versions use libgcc_s.1.1.dylib
+        ln -fs /usr/local/lib/gcc/${{ env.GCC_V }}/libgcc_s.1.dylib /usr/local/lib/gcc/10/libgcc_s.1.dylib || ln -fs /usr/local/lib/gcc/${{ env.GCC_V }}/libgcc_s.1.1.dylib /usr/local/lib/gcc/10/libgcc_s.1.dylib
+
+    - name: (macOS) Install homebrew MPICH
+      if: contains(matrix.mpi,'mpich') && contains(matrix.os,'macos')
+      run: |
+        brew install mpich
+
+    - name: (macOS) Install homebrew OpenMPI
+      if: contains(matrix.mpi,'openmpi') && contains(matrix.os,'macos')
+      run: |
+        brew install openmpi #--cc=gcc-${{ env.GCC_V }} openmpi
+
+    # Phase 1: Bootstrap fpm with existing version
+    - name: Install fpm
+      uses: fortran-lang/setup-fpm@v3
+      with:
+        fpm-version: 'v0.8.0'
+
+    - name: Remove fpm from path
+      shell: bash
+      run: |
+        mv $(which fpm) fpm-bootstrap${{ matrix.exe }}
+        echo "BOOTSTRAP=$PWD/fpm-bootstrap" >> $GITHUB_ENV
+
+    - name: Use Intel compiler for the metapackage tests
+      if: contains(matrix.mpi,'intel')
+      shell: bash
+      run: |
+        echo "FPM_FC=ifort" >> $GITHUB_ENV
+        echo "FPM_CC=icc"   >> $GITHUB_ENV
+        echo "FPM_CXX=icpc" >> $GITHUB_ENV
+
+    - name: (macOS) Use gcc/g++ instead of Clang for C/C++
+      if: contains(matrix.os,'macOS')
+      shell: bash
+      run: |
+        echo "FPM_FC=gfortran-${{ env.GCC_V }}" >> $GITHUB_ENV
+        echo "FPM_CC=gcc-${{ env.GCC_V }}"      >> $GITHUB_ENV
+        echo "FPM_CXX=g++-${{ env.GCC_V }}"     >> $GITHUB_ENV
+
+    - name: Build Fortran fpm (bootstrap)
+      shell: bash
+      run: |
+        ${{ env.BOOTSTRAP }} build
+
+    - name: Run Fortran fpm (bootstrap)
+      shell: bash
+      run: |
+        ${{ env.BOOTSTRAP }} run
+        ${{ env.BOOTSTRAP }} run -- --version
+        ${{ env.BOOTSTRAP }} run -- --help
+
+    - name: Test Fortran fpm (bootstrap)
+      if: (!contains(matrix.mpi,'intel'))
+      shell: bash
+      run: |
+        ${{ env.BOOTSTRAP }} test
+
+    - name: Install Fortran fpm (bootstrap)
+      shell: bash
+      run: |
+        ${{ env.BOOTSTRAP }} install
+
+    # Phase 2: Bootstrap fpm with itself
+    - name: Replace bootstrapping version
+      shell: bash
+      run: |
+        ${{ env.BOOTSTRAP }} run --runner cp -- fpm-debug${{ matrix.exe }}
+        rm -v ${{ env.BOOTSTRAP }}
+        echo "FPM=$PWD/fpm-debug" >> $GITHUB_ENV
+
+    - name: Get version (normal)
+      if: github.event_name != 'release'
+      shell: bash
+      run: |
+        VERSION=$(git rev-parse --short HEAD)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+
+    - name: Get version (release)
+      if: github.event_name == 'release'
+      shell: bash
+      run: |
+        VERSION=$(echo ${{ github.ref }} | cut -dv -f2)
+        echo "VERSION=$VERSION" >> $GITHUB_ENV
+        FPM_VERSION=$(${{ env.FPM }} --version | grep -o '${{ env.REGEX }}')
+        [ "$VERSION" = "$FPM_VERSION" ]
+      env:
+        REGEX: '[0-9]\{1,4\}\.[0-9]\{1,4\}\.[0-9]\{1,4\}'
+
+    - name: Build Fortran fpm
+      shell: bash
+      run: |
+        ${{ env.FPM }} build ${{ matrix.release-flags }}
+
+    - name: Run Fortran fpm
+      shell: bash
+      run: |
+        ${{ env.FPM }} run ${{ matrix.release-flags }}
+        ${{ env.FPM }} run ${{ matrix.release-flags }} -- --version
+        ${{ env.FPM }} run ${{ matrix.release-flags }} -- --help
+
+    - name: Install Fortran fpm
+      shell: bash
+      run: |
+        ${{ env.FPM }} install ${{ matrix.release-flags }}
+
+    - name: Package release version
+      shell: bash
+      run: |
+        ${{ env.FPM }} run ${{ matrix.release-flags }} --runner cp -- ${{ env.EXE }}
+        rm -v ${{ env.FPM }}
+        echo "FPM_RELEASE=${{ env.EXE }}" >> $GITHUB_ENV
+      env:
+        EXE: fpm-${{ env.VERSION }}-${{ matrix.os-arch }}${{ matrix.exe }}
+
+    - name: Run metapackage tests using the release version
+      shell: bash
+      run: |
+        ci/meta_tests.sh "$PWD/${{ env.FPM_RELEASE }}"
+
diff --git a/README.md b/README.md
index a3e3be3f77..3670cede53 100644
--- a/README.md
+++ b/README.md
@@ -33,10 +33,10 @@ non-Fortran related package manager.
 
 **Website: <https://fpm.fortran-lang.org/>**
 
-## [Download](https://fpm.fortran-lang.org/en/install/index.html)
+## [Download](https://fpm.fortran-lang.org/install/index.html)
 
 Fpm is available on many platforms and through multiple package managers, see our Documentation
-webpage for a list of **[All Supported Installations](https://fpm.fortran-lang.org/en/install/index.html)**.
+webpage for a list of **[All Supported Installations](https://fpm.fortran-lang.org/install/index.html)**.
 
 The easiest installation routes are shown below.
 
@@ -86,9 +86,9 @@ Binary distributions are available for MacOS 11 (Catalina) and 12 (Big Sur) for
 Fpm should be available and functional after those steps.
 For more details checkout the tap [here](https://github.com/fortran-lang/homebrew-fortran).
 
-## [Get started](https://fpm.fortran-lang.org/en/tutorial/index.html)
+## [Get started](https://fpm.fortran-lang.org/tutorial/index.html)
 
-**Follow our [Quickstart Tutorial](https://fpm.fortran-lang.org/en/tutorial/hello-fpm.html) to get familiar with fpm**.
+**Follow our [Quickstart Tutorial](https://fpm.fortran-lang.org/tutorial/hello-fpm.html) to get familiar with fpm**.
 
 ### Start a new project
 
@@ -118,7 +118,7 @@ arguments can also be passed to the executable(s) or test(s) with the option
 `-- some arguments`.
 
 See additional instructions in the [Packaging guide](PACKAGING.md) or
-the [manifest reference](https://fpm.fortran-lang.org/en/spec/manifest.html).
+the [manifest reference](https://fpm.fortran-lang.org/spec/manifest.html).
 
 <!-- 
 ### Bootstrapping instructions
diff --git a/ci/meta_tests.sh b/ci/meta_tests.sh
new file mode 100755
index 0000000000..c2911d2737
--- /dev/null
+++ b/ci/meta_tests.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -ex
+
+# ***********************
+# This script tests all example packages using any metapackage/system dependencies
+# ***********************
+
+cd "$(dirname $0)/.."
+
+if [ "$1" ]; then
+   fpm="$1"
+else
+   fpm=fpm
+fi
+
+# Build example packages
+pushd example_packages/
+rm -rf ./*/build
+
+pushd metapackage_openmp
+"$fpm" build --verbose
+"$fpm" run --verbose
+popd
+
+pushd metapackage_stdlib
+"$fpm" build --verbose
+"$fpm" run --verbose
+popd
+
+pushd metapackage_minpack
+"$fpm" build --verbose
+"$fpm" run --verbose
+popd
+
+pushd metapackage_mpi
+"$fpm" build --verbose 
+"$fpm" run --verbose
+popd
+
+pushd metapackage_mpi_c
+"$fpm" build --verbose 
+"$fpm" run --verbose
+popd
+
+# Cleanup
+rm -rf ./*/build
diff --git a/ci/run_tests.sh b/ci/run_tests.sh
index b0e769b73e..d84a00f1c5 100755
--- a/ci/run_tests.sh
+++ b/ci/run_tests.sh
@@ -31,6 +31,10 @@ pushd circular_example
 "$fpm" build
 popd
 
+pushd nonintrinsic
+"$fpm" build
+popd
+
 pushd hello_complex
 "$fpm" build
 "$fpm" test
@@ -146,6 +150,10 @@ pushd preprocess_cpp_deps
 "$fpm" build
 popd
 
+pushd preprocess_per_dependency
+"$fpm" run
+popd
+
 pushd preprocess_hello
 "$fpm" build
 popd
diff --git a/example_packages/metapackage_minpack/app/main.f90 b/example_packages/metapackage_minpack/app/main.f90
new file mode 100644
index 0000000000..64008e4102
--- /dev/null
+++ b/example_packages/metapackage_minpack/app/main.f90
@@ -0,0 +1,7 @@
+program main
+  use metapackage_minpack, only: simple_test
+  implicit none
+  logical :: success
+  call simple_test(success)
+  stop merge(0,1,success) 
+end program main
diff --git a/example_packages/metapackage_minpack/fpm.toml b/example_packages/metapackage_minpack/fpm.toml
new file mode 100644
index 0000000000..f178da2a48
--- /dev/null
+++ b/example_packages/metapackage_minpack/fpm.toml
@@ -0,0 +1,2 @@
+name = "metapackage_minpack"
+dependencies.minpack="*"
diff --git a/example_packages/metapackage_minpack/src/metapackage_minpack.f90 b/example_packages/metapackage_minpack/src/metapackage_minpack.f90
new file mode 100644
index 0000000000..d09d778409
--- /dev/null
+++ b/example_packages/metapackage_minpack/src/metapackage_minpack.f90
@@ -0,0 +1,14 @@
+module metapackage_minpack
+  use minpack_module, only: wp
+  use iso_fortran_env, only: real64
+  implicit none
+  private
+
+  public :: simple_test
+contains
+  subroutine simple_test(success)
+    logical, intent(out) :: success 
+    ! Success! can read minpack module
+    success = wp == real64 
+  end subroutine simple_test 
+end module metapackage_minpack
diff --git a/example_packages/metapackage_mpi/README.md b/example_packages/metapackage_mpi/README.md
new file mode 100644
index 0000000000..e1ea0c2194
--- /dev/null
+++ b/example_packages/metapackage_mpi/README.md
@@ -0,0 +1,7 @@
+# test_mpi
+This test program prints the running thread ID using MPI.
+PLEASE NOTE: 
+- Test app uses 'mpif.h' and not 'use mpi' or 'use mpi_f08' because the latter are compiler-dependent, 
+  and the MPI implementation on the local machine may not offer an implementation for them with the same 
+  compiler that fpm is using.
+- Using mpif.h will be the most backward compatible and platform agnostic
diff --git a/example_packages/metapackage_mpi/app/main.f90 b/example_packages/metapackage_mpi/app/main.f90
new file mode 100644
index 0000000000..8119ac21da
--- /dev/null
+++ b/example_packages/metapackage_mpi/app/main.f90
@@ -0,0 +1,32 @@
+program with_mpi
+  implicit none
+ 
+  include 'mpif.h'
+
+  integer, parameter :: INIT_ERROR = 1
+  integer, parameter :: RANK_ERROR = 2
+
+  integer :: ierror,ncpus,cpuid
+  
+
+  ! Initialize MPI argument
+  call MPI_INIT(ierror);  
+  if (ierror/=0) stop INIT_ERROR
+
+  ! Get number of processes and current rank 
+  call MPI_Comm_size(MPI_COMM_WORLD, ncpus, ierror)
+  if (ierror/=0) stop RANK_ERROR
+
+  call MPI_Comm_rank(MPI_COMM_WORLD, cpuid, ierror) 
+  if (ierror/=0) stop RANK_ERROR
+
+  print "('Hello, mpi world from rank ',i0,' of ',i0,'!')", cpuid+1,ncpus
+
+  ! Finalize MPI environment.
+  call MPI_FINALIZE(ierror)
+  if (ierror/=0) stop INIT_ERROR
+  
+  stop 0
+
+end program with_mpi 
+
diff --git a/example_packages/metapackage_mpi/fpm.toml b/example_packages/metapackage_mpi/fpm.toml
new file mode 100644
index 0000000000..8588e99979
--- /dev/null
+++ b/example_packages/metapackage_mpi/fpm.toml
@@ -0,0 +1,4 @@
+name = "test_mpi"
+dependencies.mpi = "*"
+fortran.implicit-external=true
+fortran.implicit-typing=true
diff --git a/example_packages/metapackage_mpi_c/README.md b/example_packages/metapackage_mpi_c/README.md
new file mode 100644
index 0000000000..6ec9d07215
--- /dev/null
+++ b/example_packages/metapackage_mpi_c/README.md
@@ -0,0 +1,2 @@
+# test_mpi
+This test program prints the running thread ID using MPI.
diff --git a/example_packages/metapackage_mpi_c/app/main.c b/example_packages/metapackage_mpi_c/app/main.c
new file mode 100644
index 0000000000..ab20ac1d16
--- /dev/null
+++ b/example_packages/metapackage_mpi_c/app/main.c
@@ -0,0 +1,34 @@
+// Test MPI linking from a C main program
+#include <mpi.h>
+#include <stdio.h>
+
+int main(int argc, char** argv)
+{
+
+  int ierror,ncpus,cpuid;
+
+  // Initialize MPI argument	
+  ierror = MPI_Init(&argc, &argv);
+  if (ierror) {
+     printf("MPI_Init failed with error %d \n",ierror);
+     return 1;
+  } 
+
+  // Get number of processes and current rank
+  MPI_Comm_size(MPI_COMM_WORLD, &ncpus);
+
+  //  Get Rank of the current process
+  MPI_Comm_rank(MPI_COMM_WORLD, &cpuid);
+
+  printf("Hello, MPI C World from rank %d of %d! \n",cpuid+1,ncpus);
+
+  // Finalize MPI environment.
+  ierror = MPI_Finalize();
+  if (ierror) {
+     printf("MPI_Finalize failed with error %d \n",ierror);
+     return 1;
+  } else {
+     return 0;
+  }
+}
+
diff --git a/example_packages/metapackage_mpi_c/fpm.toml b/example_packages/metapackage_mpi_c/fpm.toml
new file mode 100644
index 0000000000..67f4e99918
--- /dev/null
+++ b/example_packages/metapackage_mpi_c/fpm.toml
@@ -0,0 +1,9 @@
+name = "test_mpi_c"
+dependencies.mpi = "*"
+fortran.implicit-typing=true
+fortran.implicit-external=true
+
+[[executable]]
+name = "test-mpi-c-main"
+main = "main.c"
+
diff --git a/example_packages/metapackage_mpi_cpp/README.md b/example_packages/metapackage_mpi_cpp/README.md
new file mode 100644
index 0000000000..6ec9d07215
--- /dev/null
+++ b/example_packages/metapackage_mpi_cpp/README.md
@@ -0,0 +1,2 @@
+# test_mpi
+This test program prints the running thread ID using MPI.
diff --git a/example_packages/metapackage_mpi_cpp/app/main.cpp b/example_packages/metapackage_mpi_cpp/app/main.cpp
new file mode 100644
index 0000000000..45abe795a2
--- /dev/null
+++ b/example_packages/metapackage_mpi_cpp/app/main.cpp
@@ -0,0 +1,36 @@
+// Test MPI linking from a C main program
+#include <iostream>
+#include <mpi.h>
+
+using namespace std;
+
+int main(int argc, char** argv)
+{
+
+  int ierror,ncpus,cpuid;
+
+  // Initialize MPI argument	
+  ierror = MPI_Init(&argc, &argv);
+  if (ierror) {
+     cout << "MPI_Init failed with error " << ierror << endl; 
+     return 1;
+  } 
+
+  // Get number of processes and current rank
+  MPI_Comm_size(MPI_COMM_WORLD, &ncpus);
+
+  //  Get Rank of the current process
+  MPI_Comm_rank(MPI_COMM_WORLD, &cpuid);
+
+  cout << "Hello, MPI C++ World from rank " << cpuid << " of " << ncpus << "!" << endl;
+
+  // Finalize MPI environment.
+  ierror = MPI_Finalize();
+  if (ierror) {
+     cout << "MPI_Finalize failed with error " << ierror << endl; 
+     return 1;
+  } else {
+     return 0;
+  }
+}
+
diff --git a/example_packages/metapackage_mpi_cpp/fpm.toml b/example_packages/metapackage_mpi_cpp/fpm.toml
new file mode 100644
index 0000000000..4fef8f710c
--- /dev/null
+++ b/example_packages/metapackage_mpi_cpp/fpm.toml
@@ -0,0 +1,8 @@
+name = "test_mpi_cpp"
+dependencies.mpi="*"
+fortran.implicit-typing=true
+fortran.implicit-external=true
+
+[[executable]]
+name="test-mpi-cpp"
+main="main.cpp"
diff --git a/example_packages/metapackage_openmp/README.md b/example_packages/metapackage_openmp/README.md
new file mode 100644
index 0000000000..e191664959
--- /dev/null
+++ b/example_packages/metapackage_openmp/README.md
@@ -0,0 +1,4 @@
+# test_openmp
+This test program prints the running thread ID using OpenMP.
+Module omp_lib is invoked, so, this code cannot build if the OpenMP library 
+is not properly enabled by the compiler flags.
diff --git a/example_packages/metapackage_openmp/app/main.f90 b/example_packages/metapackage_openmp/app/main.f90
new file mode 100644
index 0000000000..21b0aef90f
--- /dev/null
+++ b/example_packages/metapackage_openmp/app/main.f90
@@ -0,0 +1,16 @@
+! OpenMP test case
+! This test program will only run if openmp is properly enabled in the compiler flags. 
+! Otherwise, the omp_lib module won't be found and the code cannot be built.
+program openmp_test
+  use test_openmp, only: say_hello
+  use omp_lib
+  implicit none
+
+!$omp parallel
+    call say_hello(thread_ID=OMP_GET_THREAD_NUM())
+!$omp end parallel
+
+! Successful return
+stop 0
+
+end program openmp_test
diff --git a/example_packages/metapackage_openmp/fpm.toml b/example_packages/metapackage_openmp/fpm.toml
new file mode 100644
index 0000000000..f22f381100
--- /dev/null
+++ b/example_packages/metapackage_openmp/fpm.toml
@@ -0,0 +1,3 @@
+name = "test_openmp"
+dependencies.openmp = "*"
+
diff --git a/example_packages/metapackage_openmp/src/test_openmp.f90 b/example_packages/metapackage_openmp/src/test_openmp.f90
new file mode 100644
index 0000000000..d83b4b1605
--- /dev/null
+++ b/example_packages/metapackage_openmp/src/test_openmp.f90
@@ -0,0 +1,11 @@
+module test_openmp
+  implicit none
+  private
+
+  public :: say_hello
+contains
+  subroutine say_hello(thread_ID)
+    integer, intent(in) :: thread_ID
+    print "(a,i0,a)", "Hello, test_openmp is called from thread ",thread_ID,"!"
+  end subroutine say_hello
+end module test_openmp
diff --git a/example_packages/metapackage_openmp/test/check.f90 b/example_packages/metapackage_openmp/test/check.f90
new file mode 100644
index 0000000000..d7e3cba687
--- /dev/null
+++ b/example_packages/metapackage_openmp/test/check.f90
@@ -0,0 +1,5 @@
+program check
+implicit none
+
+print *, "Put some tests in here!"
+end program check
diff --git a/example_packages/metapackage_stdlib/README.md b/example_packages/metapackage_stdlib/README.md
new file mode 100644
index 0000000000..11eddc7462
--- /dev/null
+++ b/example_packages/metapackage_stdlib/README.md
@@ -0,0 +1,4 @@
+# test_stdlib
+This test program generates a real [1,2,3,4,5] array using stdlib. 
+stdlib math and kinds modules are invoked; so this program cannot be built if stdlib is not
+properly built and linked. stdlib tests are not run in this program. 
diff --git a/example_packages/metapackage_stdlib/app/main.f90 b/example_packages/metapackage_stdlib/app/main.f90
new file mode 100644
index 0000000000..30630e90a6
--- /dev/null
+++ b/example_packages/metapackage_stdlib/app/main.f90
@@ -0,0 +1,24 @@
+! fortran-lang stdlib test case
+! This test program will only run if stdlib is properly built and linked to this project. 
+program test_stdlib_metapackage
+
+    ! These USEs would not be possible if stdlib is not found 
+    use stdlib_kinds, only: int32, int64, dp, sp
+    use stdlib_math
+    implicit none
+
+    real(dp), allocatable :: indices(:)
+
+    indices = linspace(1.0_dp,5.0_dp,5)
+
+    if (.not.allocated(indices)) then 
+       stop 1
+    elseif (size(indices)/=5) then 
+       stop 2
+    elseif (any(nint(indices)/=[1,2,3,4,5])) then 
+       stop 3
+    else
+       stop 0
+    endif
+
+end program test_stdlib_metapackage
diff --git a/example_packages/metapackage_stdlib/fpm.toml b/example_packages/metapackage_stdlib/fpm.toml
new file mode 100644
index 0000000000..3e4e8efe66
--- /dev/null
+++ b/example_packages/metapackage_stdlib/fpm.toml
@@ -0,0 +1,2 @@
+name = "test_stdlib"
+dependencies.stdlib = "*" 
diff --git a/example_packages/metapackage_stdlib/src/metapackage_stdlib.f90 b/example_packages/metapackage_stdlib/src/metapackage_stdlib.f90
new file mode 100644
index 0000000000..4f041d6d7d
--- /dev/null
+++ b/example_packages/metapackage_stdlib/src/metapackage_stdlib.f90
@@ -0,0 +1,10 @@
+module metapackage_stdlib
+  implicit none
+  private
+
+  public :: say_hello
+contains
+  subroutine say_hello
+    print *, "Hello, metapackage_stdlib!"
+  end subroutine say_hello
+end module metapackage_stdlib
diff --git a/example_packages/nonintrinsic/.gitignore b/example_packages/nonintrinsic/.gitignore
new file mode 100644
index 0000000000..a007feab07
--- /dev/null
+++ b/example_packages/nonintrinsic/.gitignore
@@ -0,0 +1 @@
+build/*
diff --git a/example_packages/nonintrinsic/app/main.f90 b/example_packages/nonintrinsic/app/main.f90
new file mode 100644
index 0000000000..a45f06d8f7
--- /dev/null
+++ b/example_packages/nonintrinsic/app/main.f90
@@ -0,0 +1,6 @@
+program test_nonintr
+    use, non_intrinsic :: iso_fortran_env
+
+    ! ijk=0 can be read
+    stop ijk
+end program test_nonintr
diff --git a/example_packages/nonintrinsic/fpm.toml b/example_packages/nonintrinsic/fpm.toml
new file mode 100644
index 0000000000..77e149814d
--- /dev/null
+++ b/example_packages/nonintrinsic/fpm.toml
@@ -0,0 +1 @@
+name = "non-intrinsic"
diff --git a/example_packages/nonintrinsic/src/iso_fortran_env.f90 b/example_packages/nonintrinsic/src/iso_fortran_env.f90
new file mode 100644
index 0000000000..20eea596f4
--- /dev/null
+++ b/example_packages/nonintrinsic/src/iso_fortran_env.f90
@@ -0,0 +1,4 @@
+module iso_fortran_env
+    implicit none
+    integer, parameter :: ijk = 0
+end module iso_fortran_env    
diff --git a/example_packages/preprocess_per_dependency/app/main.f90 b/example_packages/preprocess_per_dependency/app/main.f90
new file mode 100644
index 0000000000..aed30cd33d
--- /dev/null
+++ b/example_packages/preprocess_per_dependency/app/main.f90
@@ -0,0 +1,8 @@
+program hello_fpm
+    use utils, only: say_hello
+    integer :: ierr
+
+    call say_hello(ierr)
+    stop ierr ! ierr==0 if DEPENDENCY_MACRO is defined
+
+end program hello_fpm
diff --git a/example_packages/preprocess_per_dependency/crate/utils/fpm.toml b/example_packages/preprocess_per_dependency/crate/utils/fpm.toml
new file mode 100644
index 0000000000..f3c03f9934
--- /dev/null
+++ b/example_packages/preprocess_per_dependency/crate/utils/fpm.toml
@@ -0,0 +1,5 @@
+name = "utils"
+
+[preprocess]
+[preprocess.cpp]
+macros = ["X=1"]
diff --git a/example_packages/preprocess_per_dependency/crate/utils/src/say_hello.f90 b/example_packages/preprocess_per_dependency/crate/utils/src/say_hello.f90
new file mode 100644
index 0000000000..5f333bab7e
--- /dev/null
+++ b/example_packages/preprocess_per_dependency/crate/utils/src/say_hello.f90
@@ -0,0 +1,19 @@
+module utils
+
+    implicit none
+    
+contains
+
+    subroutine say_hello(ierr)
+        integer, intent(out) :: ierr
+
+        ierr = -1
+#ifdef DEPENDENCY_MACRO
+        ierr = 0
+#endif
+
+        print *, "Dependency macro ", merge(" IS","NOT",ierr==0)," defined" 
+
+    end subroutine say_hello
+
+end module utils
diff --git a/example_packages/preprocess_per_dependency/fpm.toml b/example_packages/preprocess_per_dependency/fpm.toml
new file mode 100644
index 0000000000..4730973ab1
--- /dev/null
+++ b/example_packages/preprocess_per_dependency/fpm.toml
@@ -0,0 +1,4 @@
+name = "preprocess_cpp_deps"
+
+[dependencies]
+utils = { path = "crate/utils" , preprocess.cpp.macros=["DEPENDENCY_MACRO"] }
diff --git a/fpm.toml b/fpm.toml
index dcd3f27743..1da1a00dcf 100644
--- a/fpm.toml
+++ b/fpm.toml
@@ -1,9 +1,9 @@
 name = "fpm"
-version = "0.8.1"
+version = "0.9.0"
 license = "MIT"
 author = "fpm maintainers"
 maintainer = ""
-copyright = "2020 fpm contributors"
+copyright = "2020-2023 fpm contributors"
 
 [preprocess]
 [preprocess.cpp]
@@ -14,8 +14,10 @@ toml-f.git = "https://github.com/toml-f/toml-f"
 toml-f.rev = "d7b892b1d074b7cfc5d75c3e0eb36ebc1f7958c1"
 M_CLI2.git = "https://github.com/urbanjost/M_CLI2.git"
 M_CLI2.rev = "7264878cdb1baff7323cc48596d829ccfe7751b8"
+fortran-regex.git  = "https://github.com/perazz/fortran-regex"
+fortran-regex.tag  = "1.1.2"
 jonquil.git = "https://github.com/toml-f/jonquil"
-jonquil.rev = "4c27c8c1e411fa8790dffcf8c3fa7a27b6322273"
+jonquil.rev = "4fbd4cf34d577c0fd25e32667ee9e41bf231ece8"
 
 [[test]]
 name = "cli-test"
diff --git a/install.sh b/install.sh
old mode 100644
new mode 100755
index 2edc239508..4243ba6266
--- a/install.sh
+++ b/install.sh
@@ -73,9 +73,9 @@ fi
 
 LATEST_RELEASE=$(get_latest_release "fortran-lang/fpm" "$FETCH")
 
+# Fallback to a latest known release if network timeout
 if [ -z "$LATEST_RELEASE" ]; then
-  echo "Could not fetch the latest release from GitHub. Install curl or wget, and ensure network connectivity."
-  exit 3
+   LATEST_RELEASE="0.8.0"
 fi
 
 SOURCE_URL="https://github.com/fortran-lang/fpm/releases/download/v${LATEST_RELEASE}/fpm-${LATEST_RELEASE}.F90"
diff --git a/src/fpm.f90 b/src/fpm.f90
index 9c63219194..8ed5fed0b1 100644
--- a/src/fpm.f90
+++ b/src/fpm.f90
@@ -19,12 +19,15 @@ module fpm
 use fpm_targets, only: targets_from_sources, build_target_t, build_target_ptr, &
                         FPM_TARGET_EXECUTABLE, FPM_TARGET_ARCHIVE
 use fpm_manifest, only : get_package_data, package_config_t
+use fpm_meta, only : resolve_metapackages
 use fpm_error, only : error_t, fatal_error, fpm_stop
 use fpm_toml, only: name_is_json
-use,intrinsic :: iso_fortran_env, only : stdin=>input_unit,   &
-                                       & stdout=>output_unit, &
-                                       & stderr=>error_unit
+use, intrinsic :: iso_fortran_env, only : stdin => input_unit, &
+                                        & stdout => output_unit, &
+                                        & stderr => error_unit
 use iso_c_binding, only: c_char, c_ptr, c_int, c_null_char, c_associated, c_f_pointer
+use fpm_environment, only: os_is_unix
+
 implicit none
 private
 public :: cmd_build, cmd_run, cmd_clean
@@ -35,13 +38,13 @@ module fpm
 !> Constructs a valid fpm model from command line settings and the toml manifest.
 subroutine build_model(model, settings, package, error)
     type(fpm_model_t), intent(out) :: model
-    type(fpm_build_settings), intent(in) :: settings
-    type(package_config_t), intent(in) :: package
+    class(fpm_build_settings), intent(inout) :: settings
+    type(package_config_t), intent(inout) :: package
     type(error_t), allocatable, intent(out) :: error
 
     integer :: i, j
     type(package_config_t) :: dependency
-    character(len=:), allocatable :: manifest, lib_dir, flags, cflags, cxxflags, ldflags
+    character(len=:), allocatable :: manifest, lib_dir
     logical :: has_cpp
     logical :: duplicates_found
     type(string_t) :: include_dir
@@ -52,49 +55,43 @@ subroutine build_model(model, settings, package, error)
     allocate(model%link_libraries(0))
     allocate(model%external_modules(0))
 
-    call new_dependency_tree(model%deps, cache=join_path("build", "cache.toml"))
-    call model%deps%add(package, error)
-    if (allocated(error)) return
-
-    ! Update dependencies where needed
-    call model%deps%update(error)
-    if (allocated(error)) return
-
-    ! build/ directory should now exist
-    if (.not.exists("build/.gitignore")) then
-      call filewrite(join_path("build", ".gitignore"),["*"])
-    end if
-
     call new_compiler(model%compiler, settings%compiler, settings%c_compiler, &
         & settings%cxx_compiler, echo=settings%verbose, verbose=settings%verbose)
     call new_archiver(model%archiver, settings%archiver, &
         & echo=settings%verbose, verbose=settings%verbose)
 
-    if (settings%flag == '') then
-        flags = model%compiler%get_default_flags(settings%profile == "release")
-    else
-        flags = settings%flag
-        select case(settings%profile)
-        case("release", "debug")
-            flags = flags // model%compiler%get_default_flags(settings%profile == "release")
-        end select
-    end if
-
-    cflags = trim(settings%cflag)
-    cxxflags = trim(settings%cxxflag)
-    ldflags = trim(settings%ldflag)
-
     if (model%compiler%is_unknown()) then
         write(*, '(*(a:,1x))') &
             "<WARN>", "Unknown compiler", model%compiler%fc, "requested!", &
             "Defaults for this compiler might be incorrect"
     end if
-    model%build_prefix = join_path("build", basename(model%compiler%fc))
 
+    call new_compiler_flags(model,settings)
+    model%build_prefix = join_path("build", basename(model%compiler%fc))
     model%include_tests = settings%build_tests
     model%enforce_module_names = package%build%module_naming
     model%module_prefix = package%build%module_prefix
 
+    ! Resolve meta-dependencies into the package and the model
+    call resolve_metapackages(model,package,settings,error)
+    if (allocated(error)) return
+
+    ! Create dependencies
+    call new_dependency_tree(model%deps, cache=join_path("build", "cache.toml"))
+
+    ! Build and resolve model dependencies
+    call model%deps%add(package, error)
+    if (allocated(error)) return
+
+    ! Update dependencies where needed
+    call model%deps%update(error)
+    if (allocated(error)) return
+
+    ! build/ directory should now exist
+    if (.not.exists("build/.gitignore")) then
+      call filewrite(join_path("build", ".gitignore"),["*"])
+    end if
+
     allocate(model%packages(model%deps%ndep))
 
     has_cpp = .false.
@@ -113,12 +110,30 @@ subroutine build_model(model, settings, package, error)
             end associate
             model%packages(i)%version = package%version%s()
 
+            !> Add this dependency's manifest macros
+            allocate(model%packages(i)%macros(0))
+
             if (allocated(dependency%preprocess)) then
                 do j = 1, size(dependency%preprocess)
                     if (dependency%preprocess(j)%name == "cpp") then
                         if (.not. has_cpp) has_cpp = .true.
                         if (allocated(dependency%preprocess(j)%macros)) then
-                            model%packages(i)%macros = dependency%preprocess(j)%macros
+                            model%packages(i)%macros = [model%packages(i)%macros, dependency%preprocess(j)%macros]
+                        end if
+                    else
+                        write(stderr, '(a)') 'Warning: Preprocessor ' // package%preprocess(i)%name // &
+                            ' is not supported; will ignore it'
+                    end if
+                end do
+            end if
+
+            !> Add this dependency's package-level macros
+            if (allocated(dep%preprocess)) then
+                do j = 1, size(dep%preprocess)
+                    if (dep%preprocess(j)%name == "cpp") then
+                        if (.not. has_cpp) has_cpp = .true.
+                        if (allocated(dep%preprocess(j)%macros)) then
+                            model%packages(i)%macros = [model%packages(i)%macros, dep%preprocess(j)%macros]
                         end if
                     else
                         write(stderr, '(a)') 'Warning: Preprocessor ' // package%preprocess(i)%name // &
@@ -167,11 +182,8 @@ subroutine build_model(model, settings, package, error)
     end do
     if (allocated(error)) return
 
-    if (has_cpp) call set_cpp_preprocessor_flags(model%compiler%id, flags)
-    model%fortran_compile_flags = flags
-    model%c_compile_flags = cflags
-    model%cxx_compile_flags = cxxflags
-    model%link_flags = ldflags
+    ! Add optional flags
+    if (has_cpp) call set_cpp_preprocessor_flags(model%compiler%id, model%fortran_compile_flags)
 
     ! Add sources from executable directories
     if (is_dir('app') .and. package%build%auto_executables) then
@@ -256,6 +268,34 @@ subroutine build_model(model, settings, package, error)
     end if
 end subroutine build_model
 
+!> Initialize model compiler flags
+subroutine new_compiler_flags(model,settings)
+    type(fpm_model_t), intent(inout) :: model
+    type(fpm_build_settings), intent(in) :: settings
+
+    character(len=:), allocatable :: flags, cflags, cxxflags, ldflags
+
+    if (settings%flag == '') then
+        flags = model%compiler%get_default_flags(settings%profile == "release")
+    else
+        flags = settings%flag
+        select case(settings%profile)
+        case("release", "debug")
+            flags = flags // model%compiler%get_default_flags(settings%profile == "release")
+        end select
+    end if
+
+    cflags   = trim(settings%cflag)
+    cxxflags = trim(settings%cxxflag)
+    ldflags  = trim(settings%ldflag)
+
+    model%fortran_compile_flags = flags
+    model%c_compile_flags       = cflags
+    model%cxx_compile_flags     = cxxflags
+    model%link_flags            = ldflags
+
+end subroutine new_compiler_flags
+
 ! Check for duplicate modules
 subroutine check_modules_for_duplicates(model, duplicates_found)
     type(fpm_model_t), intent(in) :: model
@@ -304,7 +344,7 @@ end subroutine check_modules_for_duplicates
 subroutine check_module_names(model, error)
     type(fpm_model_t), intent(in) :: model
     type(error_t), allocatable, intent(out) :: error
-    integer :: i,j,k,l,m
+    integer :: k,l,m
     logical :: valid,errors_found,enforce_this_file
     type(string_t) :: package_name,module_name,package_prefix
 
@@ -394,7 +434,7 @@ subroutine check_module_names(model, error)
 end subroutine check_module_names
 
 subroutine cmd_build(settings)
-type(fpm_build_settings), intent(in) :: settings
+type(fpm_build_settings), intent(inout) :: settings
 
 type(package_config_t) :: package
 type(fpm_model_t) :: model
@@ -437,7 +477,7 @@ subroutine cmd_build(settings)
 end subroutine cmd_build
 
 subroutine cmd_run(settings,test)
-    class(fpm_run_settings), intent(in) :: settings
+    class(fpm_run_settings), intent(inout) :: settings
     logical, intent(in) :: test
 
     integer :: i, j, col_width
@@ -460,7 +500,7 @@ subroutine cmd_run(settings,test)
         call fpm_stop(1, '*cmd_run* Package error: '//error%message)
     end if
 
-    call build_model(model, settings%fpm_build_settings, package, error)
+    call build_model(model, settings, package, error)
     if (allocated(error)) then
         call fpm_stop(1, '*cmd_run* Model error: '//error%message)
     end if
@@ -529,6 +569,8 @@ subroutine cmd_run(settings,test)
         end if
     end if
 
+
+
     ! Check all names are valid
     ! or no name and found more than one file
     toomany= size(settings%name)==0 .and. size(executables)>1
@@ -573,10 +615,10 @@ subroutine cmd_run(settings,test)
             if (exists(executables(i)%s)) then
                 if(settings%runner /= ' ')then
                     if(.not.allocated(settings%args))then
-                       call run(settings%runner//' '//executables(i)%s, &
+                       call run(settings%runner_command()//' '//executables(i)%s, &
                              echo=settings%verbose, exitstat=stat(i))
                     else
-                       call run(settings%runner//' '//executables(i)%s//" "//settings%args, &
+                       call run(settings%runner_command()//' '//executables(i)%s//" "//settings%args, &
                              echo=settings%verbose, exitstat=stat(i))
                     endif
                 else
@@ -603,17 +645,19 @@ subroutine cmd_run(settings,test)
             call fpm_stop(stat(firsterror),'*cmd_run*:stopping due to failed executions')
         end if
 
-    endif
+    end if
+
     contains
+
     subroutine compact_list_all()
     integer, parameter :: LINE_WIDTH = 80
-    integer :: i, j, nCol
-        j = 1
+    integer :: ii, jj, nCol
+        jj = 1
         nCol = LINE_WIDTH/col_width
         write(stderr,*) 'Available names:'
-        do i=1,size(targets)
+        do ii=1,size(targets)
 
-            exe_target => targets(i)%ptr
+            exe_target => targets(ii)%ptr
 
             if (exe_target%target_type == FPM_TARGET_EXECUTABLE .and. &
                 allocated(exe_target%dependencies)) then
@@ -621,11 +665,9 @@ subroutine compact_list_all()
                 exe_source => exe_target%dependencies(1)%ptr%source
 
                 if (exe_source%unit_scope == run_scope) then
-
-                    write(stderr,'(A)',advance=(merge("yes","no ",modulo(j,nCol)==0))) &
+                    write(stderr,'(A)',advance=(merge("yes","no ",modulo(jj,nCol)==0))) &
                         & [character(len=col_width) :: basename(exe_target%output_file, suffix=.false.)]
-                    j = j + 1
-
+                    jj = jj + 1
                 end if
             end if
         end do
@@ -634,15 +676,15 @@ end subroutine compact_list_all
 
     subroutine compact_list()
     integer, parameter :: LINE_WIDTH = 80
-    integer :: i, j, nCol
-        j = 1
+    integer :: ii, jj, nCol
+        jj = 1
         nCol = LINE_WIDTH/col_width
         write(stderr,*) 'Matched names:'
-        do i=1,size(executables)
-            write(stderr,'(A)',advance=(merge("yes","no ",modulo(j,nCol)==0))) &
-                & [character(len=col_width) :: basename(executables(i)%s, suffix=.false.)]
-            j = j + 1
-        enddo
+        do ii=1,size(executables)
+            write(stderr,'(A)',advance=(merge("yes","no ",modulo(jj,nCol)==0))) &
+                & [character(len=col_width) :: basename(executables(ii)%s, suffix=.false.)]
+            jj = jj + 1
+        end do
         write(stderr,*)
     end subroutine compact_list
 
@@ -663,27 +705,28 @@ subroutine delete_skip(is_unix)
     end do
 end subroutine delete_skip
 
+!> Delete the build directory including or excluding dependencies.
 subroutine cmd_clean(settings)
-    !> fpm clean called
+    !> Settings for the clean command.
     class(fpm_clean_settings), intent(in) :: settings
-    ! character(len=:), allocatable :: dir
-    ! type(string_t), allocatable :: files(:)
-    character(len=1) :: response
+
+    character :: user_response
+
     if (is_dir('build')) then
-        ! remove the entire build directory
+        ! Remove the entire build directory
         if (settings%clean_call) then
-            call os_delete_dir(settings%is_unix, 'build')
-            return
+            call os_delete_dir(os_is_unix(), 'build'); return
         end if
-        ! remove the build directory but skip dependencies
+
+        ! Remove the build directory but skip dependencies
         if (settings%clean_skip) then
-            call delete_skip(settings%is_unix)
-            return
+            call delete_skip(os_is_unix()); return
         end if
-        ! prompt to remove the build directory but skip dependencies
+
+        ! Prompt to remove the build directory but skip dependencies
         write(stdout, '(A)', advance='no') "Delete build, excluding dependencies (y/n)? "
-        read(stdin, '(A1)') response
-        if (lower(response) == 'y') call delete_skip(settings%is_unix)
+        read(stdin, '(A1)') user_response
+        if (lower(user_response) == 'y') call delete_skip(os_is_unix())
     else
         write (stdout, '(A)') "fpm: No build directory found."
     end if
diff --git a/src/fpm/cmd/export.f90 b/src/fpm/cmd/export.f90
index 6386c8853a..d2ec0dbaf1 100644
--- a/src/fpm/cmd/export.f90
+++ b/src/fpm/cmd/export.f90
@@ -16,7 +16,7 @@ module fpm_cmd_export
   !> Entry point for the export subcommand
   subroutine cmd_export(settings)
     !> Representation of the command line arguments
-    type(fpm_export_settings), intent(in) :: settings
+    type(fpm_export_settings), intent(inout) :: settings
     type(package_config_t) :: package
     type(dependency_tree_t) :: deps
     type(fpm_model_t) :: model
diff --git a/src/fpm/cmd/install.f90 b/src/fpm/cmd/install.f90
index c260bfc4df..69375a88be 100644
--- a/src/fpm/cmd/install.f90
+++ b/src/fpm/cmd/install.f90
@@ -22,7 +22,7 @@ module fpm_cmd_install
   !> Entry point for the fpm-install subcommand
   subroutine cmd_install(settings)
     !> Representation of the command line settings
-    type(fpm_install_settings), intent(in) :: settings
+    type(fpm_install_settings), intent(inout) :: settings
     type(package_config_t) :: package
     type(error_t), allocatable :: error
     type(fpm_model_t) :: model
@@ -34,7 +34,7 @@ subroutine cmd_install(settings)
     call get_package_data(package, "fpm.toml", error, apply_defaults=.true.)
     call handle_error(error)
 
-    call build_model(model, settings%fpm_build_settings, package, error)
+    call build_model(model, settings, package, error)
     call handle_error(error)
 
     call targets_from_sources(targets, model, settings%prune, error)
diff --git a/src/fpm/cmd/publish.f90 b/src/fpm/cmd/publish.f90
index 09fc465272..43636c0e30 100644
--- a/src/fpm/cmd/publish.f90
+++ b/src/fpm/cmd/publish.f90
@@ -8,8 +8,8 @@ module fpm_cmd_publish
   use fpm_model, only: fpm_model_t
   use fpm_error, only: error_t, fpm_stop
   use fpm_versioning, only: version_t
-  use fpm_filesystem, only: exists, join_path, get_tmp_directory
-  use fpm_git, only: git_archive, compressed_package_name
+  use fpm_filesystem, only: exists, join_path, get_temp_filename, delete_file
+  use fpm_git, only: git_archive
   use fpm_downloader, only: downloader_t
   use fpm_strings, only: string_t
   use fpm_settings, only: official_registry_base_url
@@ -30,8 +30,8 @@ subroutine cmd_publish(settings)
     type(fpm_model_t) :: model
     type(error_t), allocatable :: error
     type(version_t), allocatable :: version
-    type(string_t), allocatable :: form_data(:)
-    character(len=:), allocatable :: tmpdir
+    type(string_t), allocatable :: upload_data(:)
+    character(len=:), allocatable :: tmp_file
     type(downloader_t) :: downloader
     integer :: i
 
@@ -44,48 +44,75 @@ subroutine cmd_publish(settings)
       print *, version%s(); return
     end if
 
-    ! Build model to obtain dependency tree.
-    call build_model(model, settings%fpm_build_settings, package, error)
-    if (allocated(error)) call fpm_stop(1, '*cmd_build* Model error: '//error%message)
-
     !> Checks before uploading the package.
     if (.not. allocated(package%license)) call fpm_stop(1, 'No license specified in fpm.toml.')
+    if (.not. package%build%module_naming) call fpm_stop(1, 'The package does not meet the module naming requirements. '// &
+      & 'Please set "module-naming = true" in fpm.toml [build] or specify a custom module prefix.')
     if (.not. allocated(version)) call fpm_stop(1, 'No version specified in fpm.toml.')
     if (version%s() == '0') call fpm_stop(1, 'Invalid version: "'//version%s()//'".')
     if (.not. exists('fpm.toml')) call fpm_stop(1, "Cannot find 'fpm.toml' file. Are you in the project root?")
 
+    ! Build model to obtain dependency tree.
+    call build_model(model, settings%fpm_build_settings, package, error)
+    if (allocated(error)) call fpm_stop(1, '*cmd_build* Model error: '//error%message)
+
     ! Check if package contains git dependencies. Only publish packages without git dependencies.
     do i = 1, model%deps%ndep
       if (allocated(model%deps%dep(i)%git)) then
-        call fpm_stop(1, "Do not publish packages containing git dependencies. '"//model%deps%dep(i)%name//"' is a git dependency.")
+        call fpm_stop(1, 'Do not publish packages containing git dependencies. '// &
+        & "Please upload '"//model%deps%dep(i)%name//"' to the registry first.")
       end if
     end do
 
-    form_data = [ &
-      string_t('package_name="'//package%name//'"'), &
-      string_t('package_license="'//package%license//'"'), &
-      string_t('package_version="'//version%s()//'"') &
-      & ]
-
-    if (allocated(settings%token)) form_data = [form_data, string_t('upload_token="'//settings%token//'"')]
-
-    call get_tmp_directory(tmpdir, error)
-    if (allocated(error)) call fpm_stop(1, '*cmd_publish* Tmp directory error: '//error%message)
-    call git_archive('.', tmpdir, error)
-    if (allocated(error)) call fpm_stop(1, '*cmd_publish* Pack error: '//error%message)
-    form_data = [form_data, string_t('tarball=@"'//join_path(tmpdir, compressed_package_name)//'"')]
-
-    if (settings%show_form_data) then
-      do i = 1, size(form_data)
-        print *, form_data(i)%s
-      end do
-      return
+    tmp_file = get_temp_filename()
+    call git_archive('.', tmp_file, 'HEAD', settings%verbose, error)
+    if (allocated(error)) call fpm_stop(1, '*cmd_publish* Archive error: '//error%message)
+
+    upload_data = [ &
+    & string_t('package_name="'//package%name//'"'), &
+    & string_t('package_license="'//package%license//'"'), &
+    & string_t('package_version="'//version%s()//'"'), &
+    & string_t('tarball=@"'//tmp_file//'"') &
+    & ]
+
+    if (allocated(settings%token)) upload_data = [upload_data, string_t('upload_token="'//settings%token//'"')]
+
+    if (settings%show_upload_data) then
+      call print_upload_data(upload_data); return
     end if
 
     ! Make sure a token is provided for publishing.
-    if (.not. allocated(settings%token)) call fpm_stop(1, 'No token provided.')
+    if (allocated(settings%token)) then
+      if (settings%token == '') then
+        call delete_file(tmp_file); call fpm_stop(1, 'No token provided.')
+      end if
+    else
+      call delete_file(tmp_file); call fpm_stop(1, 'No token provided.')
+    end if
+
+    if (settings%verbose) then
+      call print_upload_data(upload_data)
+      print *, ''
+    end if
+
+    ! Perform network request and validate package, token etc. on the backend once
+    ! https://github.com/fortran-lang/registry/issues/41 is resolved.
+    if (settings%is_dry_run) then
+      print *, 'Dry run successful. Generated tarball: ', tmp_file; return
+    end if
 
-    call downloader%upload_form(official_registry_base_url//'/packages', form_data, error)
+    call downloader%upload_form(official_registry_base_url//'/packages', upload_data, settings%verbose, error)
+    call delete_file(tmp_file)
     if (allocated(error)) call fpm_stop(1, '*cmd_publish* Upload error: '//error%message)
   end
+
+  subroutine print_upload_data(upload_data)
+    type(string_t), intent(in) :: upload_data(:)
+    integer :: i
+
+    print *, 'Upload data:'
+    do i = 1, size(upload_data)
+      print *, upload_data(i)%s
+    end do
+  end
 end
diff --git a/src/fpm/cmd/update.f90 b/src/fpm/cmd/update.f90
index 75353c6a6e..c1f09e07c6 100644
--- a/src/fpm/cmd/update.f90
+++ b/src/fpm/cmd/update.f90
@@ -25,15 +25,13 @@ subroutine cmd_update(settings)
     call get_package_data(package, "fpm.toml", error, apply_defaults=.true.)
     call handle_error(error)
 
-    if (.not.exists("build")) then
+    if (.not. exists("build")) then
       call mkdir("build")
       call filewrite(join_path("build", ".gitignore"),["*"])
     end if
 
     cache = join_path("build", "cache.toml")
-    if (settings%clean) then
-      call delete_file(cache)
-    end if
+    if (settings%clean) call delete_file(cache)
 
     call new_dependency_tree(deps, cache=cache, &
       verbosity=merge(2, 1, settings%verbose))
diff --git a/src/fpm/dependency.f90 b/src/fpm/dependency.f90
index 7d612d92ac..71bc74514f 100644
--- a/src/fpm/dependency.f90
+++ b/src/fpm/dependency.f90
@@ -64,6 +64,7 @@ module fpm_dependency
                      serializable_t
   use fpm_manifest, only: package_config_t, dependency_config_t, get_package_data
   use fpm_manifest_dependency, only: manifest_has_changed, dependency_destroy
+  use fpm_manifest_preprocess, only: operator(==)
   use fpm_strings, only: string_t, operator(.in.)
   use fpm_toml, only: toml_table, toml_key, toml_error, toml_serialize, &
                       get_value, set_value, add_table, toml_load, toml_stat, set_string
@@ -130,7 +131,9 @@ module fpm_dependency
     type(dependency_node_t), allocatable :: dep(:)
     !> Cache file
     character(len=:), allocatable :: cache
+
   contains
+
     !> Overload procedure to add new dependencies to the tree
     generic :: add => add_project, add_project_dependencies, add_dependencies, &
       add_dependency, add_dependency_node
@@ -207,13 +210,9 @@ subroutine new_dependency_tree(self, verbosity, cache)
     call resize(self%dep)
     self%dep_dir = join_path("build", "dependencies")
 
-    if (present(verbosity)) then
-      self%verbosity = verbosity
-    end if
+    if (present(verbosity)) self%verbosity = verbosity
 
-    if (present(cache)) then
-      self%cache = cache
-    end if
+    if (present(cache)) self%cache = cache
 
   end subroutine new_dependency_tree
 
@@ -329,10 +328,10 @@ subroutine add_project(self, package, error)
       if (allocated(error)) return
 
       ! Skip root node
-      do id=2,cached%ndep
-          cached%dep(id)%cached = .true.
-          call self%add(cached%dep(id), error)
-          if (allocated(error)) return
+      do id = 2, cached%ndep
+        cached%dep(id)%cached = .true.
+        call self%add(cached%dep(id), error)
+        if (allocated(error)) return
       end do
     end if
 
@@ -456,13 +455,13 @@ subroutine add_dependency_node(self, dependency, error)
       ! the manifest has priority
       if (dependency%cached) then
         if (dependency_has_changed(dependency, self%dep(id), self%verbosity, self%unit)) then
-           if (self%verbosity>0) write (self%unit, out_fmt) "Dependency change detected:", dependency%name
-           self%dep(id)%update = .true.
+          if (self%verbosity > 0) write (self%unit, out_fmt) "Dependency change detected:", dependency%name
+          self%dep(id)%update = .true.
         else
-           ! Store the cached one
-           self%dep(id) = dependency
-           self%dep(id)%update = .false.
-        endif
+          ! Store the cached one
+          self%dep(id) = dependency
+          self%dep(id)%update = .false.
+        end if
       end if
     else
       ! New dependency: add from scratch
@@ -511,7 +510,7 @@ subroutine update_dependency(self, name, error)
 
     associate (dep => self%dep(id))
       if (allocated(dep%git) .and. dep%update) then
-        if (self%verbosity>0) write (self%unit, out_fmt) "Update:", dep%name
+        if (self%verbosity > 0) write (self%unit, out_fmt) "Update:", dep%name
         proj_dir = join_path(self%dep_dir, dep%name)
         call dep%git%checkout(proj_dir, error)
         if (allocated(error)) return
@@ -732,40 +731,45 @@ subroutine check_and_read_pkg_data(json, node, download_url, version, error)
 
     integer :: code, stat
     type(json_object), pointer :: p, q
-    character(:), allocatable :: version_key, version_str, error_message
+    character(:), allocatable :: version_key, version_str, error_message, namespace, name
+
+    namespace = ""
+    name = "UNNAMED_NODE"
+    if (allocated(node%namespace)) namespace = node%namespace
+    if (allocated(node%name)) name = node%name
 
     if (.not. json%has_key('code')) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No status code."); return
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No status code."); return
     end if
 
     call get_value(json, 'code', code, stat=stat)
     if (stat /= 0) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': "// &
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': "// &
       & "Failed to read status code."); return
     end if
 
     if (code /= 200) then
       if (.not. json%has_key('message')) then
-        call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No error message."); return
+        call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No error message."); return
       end if
 
       call get_value(json, 'message', error_message, stat=stat)
       if (stat /= 0) then
-        call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': "// &
+        call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': "// &
         & "Failed to read error message."); return
       end if
 
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"'. Status code: '"// &
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"'. Status code: '"// &
       & str(code)//"'. Error message: '"//error_message//"'."); return
     end if
 
     if (.not. json%has_key('data')) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No data."); return
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No data."); return
     end if
 
     call get_value(json, 'data', p, stat=stat)
     if (stat /= 0) then
-      call fatal_error(error, "Failed to read package data for '"//join_path(node%namespace, node%name)//"'."); return
+      call fatal_error(error, "Failed to read package data for '"//join_path(namespace, name)//"'."); return
     end if
 
     if (allocated(node%requested_version)) then
@@ -775,38 +779,38 @@ subroutine check_and_read_pkg_data(json, node, download_url, version, error)
     end if
 
     if (.not. p%has_key(version_key)) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No version data."); return
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No version data."); return
     end if
 
     call get_value(p, version_key, q, stat=stat)
     if (stat /= 0) then
-      call fatal_error(error, "Failed to retrieve version data for '"//join_path(node%namespace, node%name)//"'."); return
+      call fatal_error(error, "Failed to retrieve version data for '"//join_path(namespace, name)//"'."); return
     end if
 
     if (.not. q%has_key('download_url')) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No download url."); return
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No download url."); return
     end if
 
     call get_value(q, 'download_url', download_url, stat=stat)
     if (stat /= 0) then
-      call fatal_error(error, "Failed to read download url for '"//join_path(node%namespace, node%name)//"'."); return
+      call fatal_error(error, "Failed to read download url for '"//join_path(namespace, name)//"'."); return
     end if
 
     download_url = official_registry_base_url//download_url
 
     if (.not. q%has_key('version')) then
-      call fatal_error(error, "Failed to download '"//join_path(node%namespace, node%name)//"': No version found."); return
+      call fatal_error(error, "Failed to download '"//join_path(namespace, name)//"': No version found."); return
     end if
 
     call get_value(q, 'version', version_str, stat=stat)
     if (stat /= 0) then
-      call fatal_error(error, "Failed to read version data for '"//join_path(node%namespace, node%name)//"'."); return
+      call fatal_error(error, "Failed to read version data for '"//join_path(namespace, name)//"'."); return
     end if
 
     call new_version(version, version_str, error)
     if (allocated(error)) then
       call fatal_error(error, "'"//version_str//"' is not a valid version for '"// &
-      & join_path(node%namespace, node%name)//"'."); return
+      & join_path(namespace, name)//"'."); return
     end if
   end subroutine
 
@@ -1197,6 +1201,8 @@ logical function dependency_has_changed(cached, manifest, verbosity, iunit) resu
     !> Log verbosity
     integer, intent(in) :: verbosity, iunit
 
+    integer :: ip
+
     has_changed = .true.
 
     !> All the following entities must be equal for the dependency to not have changed
@@ -1207,27 +1213,44 @@ logical function dependency_has_changed(cached, manifest, verbosity, iunit) resu
     !> may not have it
     if (allocated(cached%version) .and. allocated(manifest%version)) then
       if (cached%version /= manifest%version) then
-         if (verbosity>1) write(iunit,out_fmt) "VERSION has changed: "//cached%version%s()//" vs. "//manifest%version%s()
-         return
-      endif
+        if (verbosity > 1) write (iunit, out_fmt) "VERSION has changed: "//cached%version%s()//" vs. "//manifest%version%s()
+        return
+      end if
     else
-       if (verbosity>1) write(iunit,out_fmt) "VERSION has changed presence "
+      if (verbosity > 1) write (iunit, out_fmt) "VERSION has changed presence "
     end if
     if (allocated(cached%revision) .and. allocated(manifest%revision)) then
       if (cached%revision /= manifest%revision) then
-        if (verbosity>1) write(iunit,out_fmt) "REVISION has changed: "//cached%revision//" vs. "//manifest%revision
+        if (verbosity > 1) write (iunit, out_fmt) "REVISION has changed: "//cached%revision//" vs. "//manifest%revision
         return
-      endif
+      end if
     else
-      if (verbosity>1) write(iunit,out_fmt) "REVISION has changed presence "
+      if (verbosity > 1) write (iunit, out_fmt) "REVISION has changed presence "
     end if
     if (allocated(cached%proj_dir) .and. allocated(manifest%proj_dir)) then
       if (cached%proj_dir /= manifest%proj_dir) then
-        if (verbosity>1) write(iunit,out_fmt) "PROJECT DIR has changed: "//cached%proj_dir//" vs. "//manifest%proj_dir
+        if (verbosity > 1) write (iunit, out_fmt) "PROJECT DIR has changed: "//cached%proj_dir//" vs. "//manifest%proj_dir
         return
+      end if
+    else
+      if (verbosity > 1) write (iunit, out_fmt) "PROJECT DIR has changed presence "
+    end if
+    if (allocated(cached%preprocess) .eqv. allocated(manifest%preprocess)) then
+      if (allocated(cached%preprocess)) then
+          if (size(cached%preprocess) /= size(manifest%preprocess)) then
+            if (verbosity > 1) write (iunit, out_fmt) "PREPROCESS has changed size"
+            return
+          end if
+          do ip=1,size(cached%preprocess)
+             if (.not.(cached%preprocess(ip) == manifest%preprocess(ip))) then
+                if (verbosity > 1) write (iunit, out_fmt) "PREPROCESS config has changed"
+                return
+             end if
+          end do
       endif
     else
-      if (verbosity>1) write(iunit,out_fmt) "PROJECT DIR has changed presence "
+      if (verbosity > 1) write (iunit, out_fmt) "PREPROCESS has changed presence "
+      return
     end if
 
     !> All checks passed: the two dependencies have no differences
diff --git a/src/fpm/downloader.f90 b/src/fpm/downloader.f90
index 7c5046df4e..39a3314ccf 100644
--- a/src/fpm/downloader.f90
+++ b/src/fpm/downloader.f90
@@ -1,6 +1,6 @@
 module fpm_downloader
   use fpm_error, only: error_t, fatal_error
-  use fpm_filesystem, only: which
+  use fpm_filesystem, only: which, run
   use fpm_versioning, only: version_t
   use jonquil, only: json_object, json_value, json_error, json_load, cast_to_object
   use fpm_strings, only: string_t
@@ -76,9 +76,14 @@ subroutine get_file(url, tmp_pkg_file, error)
   end
 
   !> Perform an http post request with form data.
-  subroutine upload_form(endpoint, form_data, error)
+  subroutine upload_form(endpoint, form_data, verbose, error)
+    !> Endpoint to upload to.
     character(len=*), intent(in) :: endpoint
+    !> Form data to upload.
     type(string_t), intent(in) :: form_data(:)
+    !> Print additional information if true.
+    logical, intent(in) :: verbose
+    !> Error handling.
     type(error_t), allocatable, intent(out) :: error
 
     integer :: stat, i
@@ -91,8 +96,8 @@ subroutine upload_form(endpoint, form_data, error)
 
     if (which('curl') /= '') then
       print *, 'Uploading package ...'
-      call execute_command_line('curl -X POST -H "Content-Type: multipart/form-data" ' &
-      & //form_data_str//endpoint, exitstat=stat)
+      call run('curl -X POST -H "Content-Type: multipart/form-data" '// &
+      & form_data_str//endpoint, exitstat=stat, echo=verbose)
     else
       call fatal_error(error, "'curl' not installed."); return
     end if
@@ -104,8 +109,11 @@ subroutine upload_form(endpoint, form_data, error)
 
   !> Unpack a tarball to a destination.
   subroutine unpack(tmp_pkg_file, destination, error)
+    !> Path to tarball.
     character(*), intent(in) :: tmp_pkg_file
+    !> Destination to unpack to.
     character(*), intent(in) :: destination
+    !> Error handling.
     type(error_t), allocatable, intent(out) :: error
 
     integer :: stat
diff --git a/src/fpm/fpm_release.f90 b/src/fpm/fpm_release.F90
similarity index 100%
rename from src/fpm/fpm_release.f90
rename to src/fpm/fpm_release.F90
diff --git a/src/fpm/git.f90 b/src/fpm/git.f90
index 3a64483e08..22b4179553 100644
--- a/src/fpm/git.f90
+++ b/src/fpm/git.f90
@@ -1,13 +1,13 @@
 !> Implementation for interacting with git repositories.
 module fpm_git
     use fpm_error, only: error_t, fatal_error
-    use fpm_filesystem, only : get_temp_filename, getline, join_path, execute_and_read_output
+    use fpm_filesystem, only : get_temp_filename, getline, join_path, execute_and_read_output, run
     use fpm_toml, only: serializable_t, toml_table, get_value, set_value, toml_stat, set_string
     implicit none
 
     public :: git_target_t, git_target_default, git_target_branch, git_target_tag, git_target_revision, git_revision, &
             & git_archive, git_matches_manifest, operator(==), compressed_package_name
-    
+
     !> Name of the compressed package that is generated temporarily.
     character(len=*), parameter :: compressed_package_name = 'compressed_package'
 
@@ -198,6 +198,8 @@ logical function git_matches_manifest(cached,manifest,verbosity,iunit)
         !> while the cached dependency always stores a commit hash because it's built
         !> after the repo is available (saved as git_descriptor%revision==revision).
         !> So, comparing against the descriptor is not reliable
+        git_matches_manifest = allocated(cached%object) .eqv. allocated(manifest%object)
+        if (git_matches_manifest .and. allocated(cached%object)) &
         git_matches_manifest = cached%object == manifest%object
         if (.not.git_matches_manifest) then
             if (verbosity>1) write(iunit,out_fmt) "GIT OBJECT has changed: ",cached%object," vs. ", manifest%object
@@ -422,18 +424,22 @@ pure function descriptor_name(descriptor) result(name)
     end function descriptor_name
 
   !> Archive a folder using `git archive`.
-  subroutine git_archive(source, destination, error)
+  subroutine git_archive(source, destination, ref, verbose, error)
     !> Directory to archive.
     character(*), intent(in) :: source
     !> Destination of the archive.
     character(*), intent(in) :: destination
+    !> (Symbolic) Reference to be archived.
+    character(*), intent(in) :: ref
+    !> Print additional information if true.
+    logical, intent(in) :: verbose
     !> Error handling.
     type(error_t), allocatable, intent(out) :: error
 
     integer :: stat
     character(len=:), allocatable :: cmd_output, archive_format
 
-    call execute_and_read_output('git archive -l', cmd_output, error)
+    call execute_and_read_output('git archive -l', cmd_output, error, verbose)
     if (allocated(error)) return
 
     if (index(cmd_output, 'tar.gz') /= 0) then
@@ -442,12 +448,10 @@ subroutine git_archive(source, destination, error)
       call fatal_error(error, "Cannot find a suitable archive format for 'git archive'."); return
     end if
 
-    call execute_command_line('git archive HEAD --format='//archive_format//' -o '// &
-    & join_path(destination, compressed_package_name), exitstat=stat)
+    call run('git archive '//ref//' --format='//archive_format//' -o '//destination, echo=verbose, exitstat=stat)
     if (stat /= 0) then
       call fatal_error(error, "Error packing '"//source//"'."); return
     end if
   end
 
-
 end module fpm_git
diff --git a/src/fpm/manifest/dependency.f90 b/src/fpm/manifest/dependency.f90
index b6f0e1e810..3ebbad7de6 100644
--- a/src/fpm/manifest/dependency.f90
+++ b/src/fpm/manifest/dependency.f90
@@ -28,9 +28,13 @@ module fpm_manifest_dependency
         & git_target_revision, git_target_default, operator(==), git_matches_manifest
     use fpm_toml, only: toml_table, toml_key, toml_stat, get_value, check_keys, serializable_t, add_table, &
         & set_value, set_string
-    use fpm_filesystem, only: windows_path
+    use fpm_filesystem, only: windows_path, join_path
     use fpm_environment, only: get_os_type, OS_WINDOWS
+    use fpm_manifest_metapackages, only: metapackage_config_t, is_meta_package, new_meta_config, &
+            metapackage_request_t, new_meta_request
     use fpm_versioning, only: version_t, new_version
+    use fpm_strings, only: string_t
+    use fpm_manifest_preprocess
     implicit none
     private
 
@@ -55,6 +59,9 @@ module fpm_manifest_dependency
         !> The latest version is used if not specified.
         type(version_t), allocatable :: requested_version
 
+        !> Requested macros for the dependency
+        type(preprocess_config_t), allocatable :: preprocess(:)
+
         !> Git descriptor
         type(git_target_t), allocatable :: git
 
@@ -96,16 +103,32 @@ subroutine new_dependency(self, table, root, error)
 
         character(len=:), allocatable :: uri, value, requested_version
 
+        type(toml_table), pointer :: child
+
         call check(table, error)
         if (allocated(error)) return
 
         call table%get_key(self%name)
         call get_value(table, "namespace", self%namespace)
 
+        call get_value(table, "v", requested_version)
+        if (allocated(requested_version)) then
+            if (.not. allocated(self%requested_version)) allocate (self%requested_version)
+            call new_version(self%requested_version, requested_version, error)
+            if (allocated(error)) return
+        end if
+
+        !> Get optional preprocessor directives
+        call get_value(table, "preprocess", child, requested=.false.)
+        if (associated(child)) then
+            call new_preprocessors(self%preprocess, child, error)
+            if (allocated(error)) return
+        endif
+
         call get_value(table, "path", uri)
         if (allocated(uri)) then
             if (get_os_type() == OS_WINDOWS) uri = windows_path(uri)
-            if (present(root)) uri = root//uri  ! Relative to the fpm.toml it’s written in
+            if (present(root)) uri = join_path(root,uri)  ! Relative to the fpm.toml it’s written in
             call move_alloc(uri, self%path)
             return
         end if
@@ -137,14 +160,6 @@ subroutine new_dependency(self, table, root, error)
             return
         end if
 
-        call get_value(table, "v", requested_version)
-
-        if (allocated(requested_version)) then
-            if (.not. allocated(self%requested_version)) allocate (self%requested_version)
-            call new_version(self%requested_version, requested_version, error)
-            if (allocated(error)) return
-        end if
-
     end subroutine new_dependency
 
     !> Check local schema for allowed entries
@@ -158,6 +173,7 @@ subroutine check(table, error)
 
         character(len=:), allocatable :: name
         type(toml_key), allocatable :: list(:)
+        type(toml_table), pointer :: child
 
         !> List of valid keys for the dependency table.
         character(*), dimension(*), parameter :: valid_keys = [character(24) :: &
@@ -167,7 +183,8 @@ subroutine check(table, error)
               "git", &
               "tag", &
               "branch", &
-              "rev" &
+              "rev", &
+              "preprocess" &
             & ]
 
         call table%get_key(name)
@@ -211,14 +228,29 @@ subroutine check(table, error)
             return
         end if
 
+        ! Check preprocess key
+        if (table%has_key('preprocess')) then
+
+            call get_value(table, 'preprocess', child)
+
+            if (.not.associated(child)) then
+                call syntax_error(error, "Dependency '"//name//"' has invalid 'preprocess' entry")
+                return
+            end if
+
+        end if
+
     end subroutine check
 
     !> Construct new dependency array from a TOML data structure
-    subroutine new_dependencies(deps, table, root, error)
+    subroutine new_dependencies(deps, table, root, meta, error)
 
         !> Instance of the dependency configuration
         type(dependency_config_t), allocatable, intent(out) :: deps(:)
 
+        !> (optional) metapackages
+        type(metapackage_config_t), optional, intent(out) :: meta
+
         !> Instance of the TOML data structure
         type(toml_table), intent(inout) :: table
 
@@ -230,23 +262,67 @@ subroutine new_dependencies(deps, table, root, error)
 
         type(toml_table), pointer :: node
         type(toml_key), allocatable :: list(:)
-        integer :: idep, stat
+        type(dependency_config_t), allocatable :: all_deps(:)
+        type(metapackage_request_t) :: meta_request
+        logical, allocatable :: is_meta(:)
+        logical :: metapackages_allowed
+        integer :: idep, stat, ndep
 
         call table%get_keys(list)
         ! An empty table is okay
         if (size(list) < 1) return
 
-        allocate (deps(size(list)))
+        !> Flag dependencies that should be treated as metapackages
+        metapackages_allowed = present(meta)
+        allocate(is_meta(size(list)),source=.false.)
+        allocate(all_deps(size(list)))
+
+        !> Parse all meta- and non-metapackage dependencies
         do idep = 1, size(list)
+
+            ! Check if this is a standard dependency node
             call get_value(table, list(idep)%key, node, stat=stat)
-            if (stat /= toml_stat%success) then
-                call syntax_error(error, "Dependency "//list(idep)%key//" must be a table entry")
-                exit
-            end if
-            call new_dependency(deps(idep), node, root, error)
-            if (allocated(error)) exit
+            is_standard_dependency: if (stat /= toml_stat%success) then
+
+                ! See if it can be a valid metapackage name
+                call new_meta_request(meta_request, list(idep)%key, table, error=error)
+
+                !> Neither a standard dep nor a metapackage
+                if (allocated(error)) then
+                   call syntax_error(error, "Dependency "//list(idep)%key//" is not a valid metapackage or a table entry")
+                   return
+                endif
+
+                !> Valid meta dependency
+                is_meta(idep) = .true.
+
+            else
+
+                ! Parse as a standard dependency
+                is_meta(idep) = .false.
+
+                call new_dependency(all_deps(idep), node, root, error)
+                if (allocated(error)) return
+
+            end if is_standard_dependency
+
         end do
 
+        ! Non-meta dependencies
+        ndep = count(.not.is_meta)
+
+        ! Finalize standard dependencies
+        allocate(deps(ndep))
+        ndep = 0
+        do idep = 1, size(list)
+            if (is_meta(idep)) cycle
+            ndep = ndep+1
+            deps(ndep) = all_deps(idep)
+        end do
+
+        ! Finalize meta dependencies
+        if (metapackages_allowed) call new_meta_config(meta,table,is_meta,error)
+
     end subroutine new_dependencies
 
     !> Write information on instance
diff --git a/src/fpm/manifest/meta.f90 b/src/fpm/manifest/meta.f90
new file mode 100644
index 0000000000..3719067030
--- /dev/null
+++ b/src/fpm/manifest/meta.f90
@@ -0,0 +1,221 @@
+!> Implementation of the metapackage configuration data.
+!>
+!> A metapackage table can currently have the following fields
+!>
+!>```toml
+!>[metapackages]
+!>fpm = "0.1.0"
+!>openmp = bool
+!>stdlib = bool
+!>```
+module fpm_manifest_metapackages
+    use fpm_error, only: error_t, fatal_error, syntax_error
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value
+    use fpm_environment
+    implicit none
+    private
+
+    public :: metapackage_config_t, new_meta_config, is_meta_package
+    public :: metapackage_request_t, new_meta_request
+
+
+    !> Configuration data for a single metapackage request
+    type :: metapackage_request_t
+
+        !> Request flag
+        logical :: on = .false.
+
+        !> Metapackage name
+        character(len=:), allocatable :: name
+
+        !> Version Specification string
+        character(len=:), allocatable :: version
+
+    end type metapackage_request_t
+
+
+    !> Configuration data for metapackages
+    type :: metapackage_config_t
+
+        !> Request MPI support
+        type(metapackage_request_t) :: mpi
+
+        !> Request OpenMP support
+        type(metapackage_request_t) :: openmp
+
+        !> Request stdlib support
+        type(metapackage_request_t) :: stdlib
+
+        !> fortran-lang minpack
+        type(metapackage_request_t) :: minpack
+
+    end type metapackage_config_t
+
+
+contains
+
+    !> Destroy a metapackage request
+    elemental subroutine request_destroy(self)
+
+        !> Instance of the request
+        class(metapackage_request_t), intent(inout) :: self
+
+        self%on = .false.
+        if (allocated(self%version)) deallocate(self%version)
+        if (allocated(self%name)) deallocate(self%name)
+
+    end subroutine request_destroy
+
+    !> Parse version string of a metapackage request
+    subroutine request_parse(self, version_request, error)
+
+        ! Instance of this metapackage
+        type(metapackage_request_t), intent(inout) :: self
+
+        ! Parse version request
+        character(len=*), intent(in) :: version_request
+
+        ! Error message
+        type(error_t), allocatable, intent(out) :: error
+
+        ! wildcard = use any versions
+        if (version_request=="*") then
+
+            ! Any version is OK
+            self%on = .true.
+            self%version = version_request
+
+        else
+
+            call fatal_error(error,'Value <'//version_request//'> for metapackage '//self%name//&
+                                   'is not currently supported. Try "*" instead. ')
+            return
+
+        end if
+
+    end subroutine request_parse
+
+    !> Construct a new metapackage request from the dependencies table
+    subroutine new_meta_request(self, key, table, meta_allowed, error)
+
+        type(metapackage_request_t), intent(out) :: self
+
+        !> The package name
+        character(len=*), intent(in) :: key
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> List of keys allowed to be metapackages
+        logical, intent(in), optional :: meta_allowed(:)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+
+        integer :: stat,i
+        character(len=:), allocatable :: value
+        logical, allocatable :: allow_meta(:)
+        type(toml_key), allocatable :: keys(:)
+
+        call request_destroy(self)
+
+        !> Set name
+        self%name = key
+        if (.not.is_meta_package(key)) then
+            call fatal_error(error,"Error reading fpm.toml: <"//key//"> is not a valid metapackage name")
+            return
+        end if
+
+        !> The toml table is not checked here because it already passed
+        !> the "new_dependencies" check
+
+        call table%get_keys(keys)
+
+        !> Set list of entries that are allowed to be metapackages
+        if (present(meta_allowed)) then
+            if (size(meta_allowed)/=size(keys)) then
+                 call fatal_error(error,"Internal error: list of metapackage-enable entries does not match table size")
+                 return
+            end if
+            allow_meta = meta_allowed
+        else
+            allocate(allow_meta(size(keys)),source=.true.)
+        endif
+
+
+        do i=1,size(keys)
+
+            ! Skip standard dependencies
+            if (.not.allow_meta(i)) cycle
+
+            if (keys(i)%key==key) then
+                call get_value(table, key, value)
+                if (.not. allocated(value)) then
+                    call syntax_error(error, "Could not retrieve version string for metapackage key <"//key//">. Check syntax")
+                    return
+                else
+                    call request_parse(self, value, error)
+                    return
+                endif
+            end if
+        end do
+
+        ! Key is not present, metapackage not requested
+        return
+
+    end subroutine new_meta_request
+
+    !> Construct a new build configuration from a TOML data structure
+    subroutine new_meta_config(self, table, meta_allowed, error)
+
+        !> Instance of the build configuration
+        type(metapackage_config_t), intent(out) :: self
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> List of keys allowed to be metapackages
+        logical, intent(in) :: meta_allowed(:)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: stat
+
+        !> The toml table is not checked here because it already passed
+        !> the "new_dependencies" check
+        call new_meta_request(self%openmp, "openmp", table, meta_allowed, error)
+        if (allocated(error)) return
+
+        call new_meta_request(self%stdlib, "stdlib", table, meta_allowed, error)
+        if (allocated(error)) return
+
+        call new_meta_request(self%minpack, "minpack", table, meta_allowed, error)
+        if (allocated(error)) return
+
+        call new_meta_request(self%mpi, "mpi", table, meta_allowed, error)
+        if (allocated(error)) return
+
+    end subroutine new_meta_config
+
+    !> Check local schema for allowed entries
+    logical function is_meta_package(key)
+
+        !> Instance of the TOML data structure
+        character(*), intent(in) :: key
+
+        select case (key)
+
+            !> Supported metapackages
+            case ("openmp","stdlib","mpi","minpack")
+                is_meta_package = .true.
+
+            case default
+                is_meta_package = .false.
+
+        end select
+
+    end function is_meta_package
+
+end module fpm_manifest_metapackages
diff --git a/src/fpm/manifest/package.f90 b/src/fpm/manifest/package.f90
index 57ab93110c..78bbb4d4df 100644
--- a/src/fpm/manifest/package.f90
+++ b/src/fpm/manifest/package.f90
@@ -44,6 +44,7 @@ module fpm_manifest_package
     use fpm_manifest_install, only: install_config_t, new_install_config
     use fpm_manifest_test, only : test_config_t, new_test
     use fpm_manifest_preprocess, only : preprocess_config_t, new_preprocessors
+    use fpm_manifest_metapackages, only: metapackage_config_t, new_meta_config
     use fpm_filesystem, only : exists, getline, join_path
     use fpm_error, only : error_t, fatal_error, syntax_error, bad_name_error
     use fpm_toml, only : toml_table, toml_array, toml_key, toml_stat, get_value, len, &
@@ -73,6 +74,9 @@ module fpm_manifest_package
         !> Build configuration data
         type(build_config_t) :: build
 
+        !> Metapackage data
+        type(metapackage_config_t) :: meta
+
         !> Installation configuration data
         type(install_config_t) :: install
 
@@ -234,13 +238,13 @@ subroutine new_package(self, table, root, error)
 
         call get_value(table, "dependencies", child, requested=.false.)
         if (associated(child)) then
-            call new_dependencies(self%dependency, child, root, error)
+            call new_dependencies(self%dependency, child, root, self%meta, error)
             if (allocated(error)) return
         end if
 
         call get_value(table, "dev-dependencies", child, requested=.false.)
         if (associated(child)) then
-            call new_dependencies(self%dev_dependency, child, root, error)
+            call new_dependencies(self%dev_dependency, child, root, error=error)
             if (allocated(error)) return
         end if
 
diff --git a/src/fpm/manifest/preprocess.f90 b/src/fpm/manifest/preprocess.f90
index 6d7df28871..f5ea93b0f4 100644
--- a/src/fpm/manifest/preprocess.f90
+++ b/src/fpm/manifest/preprocess.f90
@@ -18,7 +18,7 @@ module fpm_manifest_preprocess
    implicit none
    private
 
-   public :: preprocess_config_t, new_preprocess_config, new_preprocessors
+   public :: preprocess_config_t, new_preprocess_config, new_preprocessors, operator(==)
 
    !> Configuration meta data for a preprocessor
    type, extends(serializable_t) :: preprocess_config_t
@@ -49,6 +49,10 @@ module fpm_manifest_preprocess
 
    character(*), parameter, private :: class_name = 'preprocess_config_t'
 
+   interface operator(==)
+       module procedure preprocess_is_same
+   end interface
+
 contains
 
    !> Construct a new preprocess configuration from TOML data structure
@@ -193,6 +197,9 @@ logical function preprocess_is_same(this,that)
       class(preprocess_config_t), intent(in) :: this
       class(serializable_t), intent(in) :: that
 
+      integer :: istr
+
+
       preprocess_is_same = .false.
 
       select type (other=>that)
@@ -201,6 +208,7 @@ logical function preprocess_is_same(this,that)
             if (allocated(this%name)) then
                 if (.not.(this%name==other%name)) return
             endif
+
             if (.not.(this%suffixes==other%suffixes)) return
             if (.not.(this%directories==other%directories)) return
             if (.not.(this%macros==other%macros)) return
diff --git a/src/fpm/manifest/profiles.f90 b/src/fpm/manifest/profiles.f90
index 6b139910d9..f50cf32cff 100644
--- a/src/fpm/manifest/profiles.f90
+++ b/src/fpm/manifest/profiles.f90
@@ -749,25 +749,25 @@ function get_default_profiles(error) result(default_profiles)
                 & 'ifort', &
                 & OS_ALL, &
                 & flags = ' -fp-model precise -pc64 -align all -error-limit 1 -reentrancy&
-                          & threaded -nogen-interfaces -assume byterecl', &
+                          & threaded -nogen-interfaces -assume byterecl -standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('release', &
                 & 'ifort', &
                 & OS_WINDOWS, &
                 & flags = ' /fp:precise /align:all /error-limit:1 /reentrancy:threaded&
-                          & /nogen-interfaces /assume:byterecl', &
+                          & /nogen-interfaces /assume:byterecl /standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('release', &
                 & 'ifx', &
                 & OS_ALL, &
                 & flags = ' -fp-model=precise -pc64 -align all -error-limit 1 -reentrancy&
-                          & threaded -nogen-interfaces -assume byterecl', &
+                          & threaded -nogen-interfaces -assume byterecl -standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('release', &
                 & 'ifx', &
                 & OS_WINDOWS, &
                 & flags = ' /fp:precise /align:all /error-limit:1 /reentrancy:threaded&
-                          & /nogen-interfaces /assume:byterecl', &
+                          & /nogen-interfaces /assume:byterecl /standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('release', &
                 &'nagfor', &
@@ -805,28 +805,28 @@ function get_default_profiles(error) result(default_profiles)
               & new_profile('debug', &
                 & 'ifort', &
                 & OS_ALL, &
-                & flags = ' -warn all -check all -error-limit 1 -O0 -g -assume byterecl -traceback', &
+                & flags = ' -warn all -check all -error-limit 1 -O0 -g -assume byterecl -standard-semantics -traceback', &
                 & is_built_in=.true.), &
               & new_profile('debug', &
                 & 'ifort', &
                 & OS_WINDOWS, &
                 & flags = ' /warn:all /check:all /error-limit:1&
-                          & /Od /Z7 /assume:byterecl /traceback', &
+                          & /Od /Z7 /assume:byterecl /standard-semantics /traceback', &
                 & is_built_in=.true.), &
               & new_profile('debug', &
                 & 'ifx', &
                 & OS_ALL, &
-                & flags = ' -warn all -check all -error-limit 1 -O0 -g -assume byterecl -traceback', &
+                & flags = ' -warn all -check all -error-limit 1 -O0 -g -assume byterecl -standard-semantics -traceback', &
                 & is_built_in=.true.), &
               & new_profile('debug', &
                 & 'ifx', &
                 & OS_WINDOWS, &
-                & flags = ' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl', &
+                & flags = ' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl /standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('debug', &
                 & 'ifx', &
                 & OS_WINDOWS, &
-                & flags = ' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl', &
+                & flags = ' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl /standard-semantics', &
                 & is_built_in=.true.), &
               & new_profile('debug', &
                 & 'lfortran', &
diff --git a/src/fpm/toml.f90 b/src/fpm/toml.f90
index bf8997fdf8..2f0947d6a5 100644
--- a/src/fpm/toml.f90
+++ b/src/fpm/toml.f90
@@ -724,6 +724,7 @@ subroutine check_keys(table, valid_keys, error)
         type(error_t), allocatable, intent(out) :: error
 
         type(toml_key), allocatable :: keys(:)
+        type(toml_table), pointer :: child
         character(:), allocatable :: name, value, valid_keys_string
         integer :: ikey, ivalid
 
@@ -744,12 +745,18 @@ subroutine check_keys(table, valid_keys, error)
             end if
 
             ! Check if value can be mapped or else (wrong type) show error message with the error location.
-            ! Right now, it can only be mapped to a string, but this can be extended in the future.
+            ! Right now, it can only be mapped to a string or to a child node, but this can be extended in the future.
             call get_value(table, keys(ikey)%key, value)
             if (.not. allocated(value)) then
-                allocate (error)
-                error%message = "'"//name//"' has an invalid '"//keys(ikey)%key//"' entry."
-                return
+
+                ! If value is not a string, check if it is a child node
+                call get_value(table, keys(ikey)%key, child)
+
+                if (.not.associated(child)) then
+                    allocate (error)
+                    error%message = "'"//name//"' has an invalid '"//keys(ikey)%key//"' entry."
+                    return
+                endif
             end if
         end do
 
diff --git a/src/fpm/versioning.f90 b/src/fpm/versioning.f90
index d8f4f46432..82f980bc95 100644
--- a/src/fpm/versioning.f90
+++ b/src/fpm/versioning.f90
@@ -1,10 +1,13 @@
 !> Implementation of versioning data for comparing packages
 module fpm_versioning
     use fpm_error, only : error_t, syntax_error
+    use fpm_strings, only: string_t
+    use regex_module, only: regex
     implicit none
     private
 
     public :: version_t, new_version
+    public :: regex_version_from_text
 
 
     type :: version_t
@@ -402,5 +405,38 @@ elemental integer function ndigits(self)
 
     end function ndigits
 
+    ! Extract canonical version flags "1.0.0" or "1.0" as the first instance inside a text
+    ! (whatever long) using regex
+    type(string_t) function regex_version_from_text(text,what,error) result(ver)
+        character(*), intent(in) :: text
+        character(*), intent(in) :: what
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: ire, length
+
+        if (len_trim(text)<=0) then
+            call syntax_error(error,'cannot retrieve '//what//' version: empty input string')
+            return
+        end if
+
+        ! Extract 3-sized version "1.0.4"
+        ire = regex(text,'\d+\.\d+\.\d+',length=length)
+        if (ire>0 .and. length>0) then
+            ! Parse version into the object (this should always work)
+            ver = string_t(text(ire:ire+length-1))
+        else
+
+            ! Try 2-sized version "1.0"
+            ire = regex(text,'\d+\.\d+',length=length)
+
+            if (ire>0 .and. length>0) then
+                ver = string_t(text(ire:ire+length-1))
+            else
+                call syntax_error(error,'cannot retrieve '//what//' version.')
+            end if
+
+        end if
+
+    end function regex_version_from_text
 
 end module fpm_versioning
diff --git a/src/fpm_command_line.f90 b/src/fpm_command_line.f90
index 6b545b5dce..2b5081237a 100644
--- a/src/fpm_command_line.f90
+++ b/src/fpm_command_line.f90
@@ -23,12 +23,12 @@
 !> ``fpm-help`` and ``fpm --list`` help pages below to make sure the help output
 !> is complete and consistent as well.
 module fpm_command_line
-use fpm_environment,  only : get_os_type, get_env, os_is_unix, &
+use fpm_environment,  only : get_os_type, get_env, &
                              OS_UNKNOWN, OS_LINUX, OS_MACOS, OS_WINDOWS, &
                              OS_CYGWIN, OS_SOLARIS, OS_FREEBSD, OS_OPENBSD, OS_NAME
 use M_CLI2,           only : set_args, lget, sget, unnamed, remaining, specified
 use M_CLI2,           only : get_subcommand, CLI_RESPONSE_FILE
-use fpm_strings,      only : lower, split, to_fortran_name, is_fortran_name
+use fpm_strings,      only : lower, split, to_fortran_name, is_fortran_name, remove_characters_in_set, string_t
 use fpm_filesystem,   only : basename, canon_path, which, run
 use fpm_environment,  only : get_command_arguments_quoted
 use fpm_error,        only : fpm_stop, error_t
@@ -90,9 +90,12 @@ module fpm_command_line
 
 type, extends(fpm_build_settings)  :: fpm_run_settings
     character(len=ibug),allocatable :: name(:)
-    character(len=:),allocatable :: args
+    character(len=:),allocatable :: args ! passed to the app
     character(len=:),allocatable :: runner
+    character(len=:),allocatable :: runner_args ! passed to the runner
     logical :: example
+    contains
+       procedure :: runner_command
 end type
 
 type, extends(fpm_run_settings)  :: fpm_test_settings
@@ -122,15 +125,14 @@ module fpm_command_line
 end type
 
 type, extends(fpm_cmd_settings)   :: fpm_clean_settings
-    logical                       :: is_unix
-    character(len=:), allocatable :: calling_dir  ! directory clean called from
-    logical                       :: clean_skip=.false.
-    logical                       :: clean_call=.false.
+    logical                       :: clean_skip = .false.
+    logical                       :: clean_call = .false.
 end type
 
 type, extends(fpm_build_settings) :: fpm_publish_settings
     logical :: show_package_version = .false.
-    logical :: show_form_data = .false.
+    logical :: show_upload_data = .false.
+    logical :: is_dry_run = .false.
     character(len=:), allocatable :: token
 end type
 
@@ -150,7 +152,8 @@ module fpm_command_line
 &  'test',  'runner', 'install', 'update', 'list',   'help',   'version', 'publish' ]
 
 character(len=:), allocatable :: val_runner, val_compiler, val_flag, val_cflag, val_cxxflag, val_ldflag, &
-    val_profile, val_dump
+    val_profile, val_runner_args, val_dump
+
 
 !   '12345678901234567890123456789012345678901234567890123456789012345678901234567890',&
 character(len=80), parameter :: help_text_build_common(*) = [character(len=80) ::      &
@@ -178,7 +181,7 @@ module fpm_command_line
     ' --flag  FFLAGS    selects compile arguments for the build, the default value is',&
     '                   set by the FPM_FFLAGS environment variable. These are added  ',&
     '                   to the profile options if --profile is specified, else these ',&
-    '                   these options override the defaults. Note object and .mod    ',&
+    '                   options override the defaults. Note object and .mod          ',&
     '                   directory locations are always built in.                     ',&
     ' --c-flag CFLAGS   selects compile arguments specific for C source in the build.',&
     '                   The default value is set by the FPM_CFLAGS environment       ',&
@@ -226,13 +229,12 @@ subroutine get_command_line_settings(cmd_settings)
         character(len=4096)           :: cmdarg
         integer                       :: i
         integer                       :: os
-        logical                       :: is_unix
         type(fpm_install_settings), allocatable :: install_settings
         type(fpm_publish_settings), allocatable :: publish_settings
         type(fpm_export_settings) , allocatable :: export_settings
         type(version_t) :: version
         character(len=:), allocatable :: common_args, compiler_args, run_args, working_dir, &
-            & c_compiler, cxx_compiler, archiver, version_s
+            & c_compiler, cxx_compiler, archiver, version_s, token_s
 
         character(len=*), parameter :: fc_env = "FC", cc_env = "CC", ar_env = "AR", &
             & fflags_env = "FFLAGS", cflags_env = "CFLAGS", cxxflags_env = "CXXFLAGS", ldflags_env = "LDFLAGS", &
@@ -243,8 +245,17 @@ subroutine get_command_line_settings(cmd_settings)
         call set_help()
         os = get_os_type()
         ! text for --version switch,
-        os_type = "OS Type:     "//OS_NAME(os)
-        is_unix = os_is_unix(os)
+        select case (os)
+            case (OS_LINUX);   os_type =  "OS Type:     Linux"
+            case (OS_MACOS);   os_type =  "OS Type:     macOS"
+            case (OS_WINDOWS); os_type =  "OS Type:     Windows"
+            case (OS_CYGWIN);  os_type =  "OS Type:     Cygwin"
+            case (OS_SOLARIS); os_type =  "OS Type:     Solaris"
+            case (OS_FREEBSD); os_type =  "OS Type:     FreeBSD"
+            case (OS_OPENBSD); os_type =  "OS Type:     OpenBSD"
+            case (OS_UNKNOWN); os_type =  "OS Type:     Unknown"
+            case default     ; os_type =  "OS Type:     UNKNOWN"
+        end select
 
         ! Get current release version
         version = fpm_version()
@@ -269,7 +280,8 @@ subroutine get_command_line_settings(cmd_settings)
         run_args = &
           ' --target " "' // &
           ' --list F' // &
-          ' --runner " "'
+          ' --runner " "' // &
+          ' --runner-args " "'
 
         compiler_args = &
           ' --profile " "' // &
@@ -318,12 +330,18 @@ subroutine get_command_line_settings(cmd_settings)
                if(names(i)=='..')names(i)='*'
             enddo
 
+            ! If there are additional command-line arguments, remove the additional
+            ! double quotes which have been added by M_CLI2
+            val_runner_args=sget('runner-args')
+            call remove_characters_in_set(val_runner_args,set='"')
+
             c_compiler = sget('c-compiler')
             cxx_compiler = sget('cxx-compiler')
             archiver = sget('archiver')
             allocate(fpm_run_settings :: cmd_settings)
             val_runner=sget('runner')
             if(specified('runner') .and. val_runner=='')val_runner='echo'
+
             cmd_settings=fpm_run_settings(&
             & args=remaining,&
             & profile=val_profile,&
@@ -341,6 +359,7 @@ subroutine get_command_line_settings(cmd_settings)
             & build_tests=.false.,&
             & name=names,&
             & runner=val_runner,&
+            & runner_args=val_runner_args, &
             & verbose=lget('verbose') )
 
         case('build')
@@ -572,12 +591,18 @@ subroutine get_command_line_settings(cmd_settings)
                if(names(i)=='..')names(i)='*'
             enddo
 
+            ! If there are additional command-line arguments, remove the additional
+            ! double quotes which have been added by M_CLI2
+            val_runner_args=sget('runner-args')
+            call remove_characters_in_set(val_runner_args,set='"')
+
             c_compiler = sget('c-compiler')
             cxx_compiler = sget('cxx-compiler')
             archiver = sget('archiver')
             allocate(fpm_test_settings :: cmd_settings)
             val_runner=sget('runner')
             if(specified('runner') .and. val_runner=='')val_runner='echo'
+
             cmd_settings=fpm_test_settings(&
             & args=remaining, &
             & profile=val_profile, &
@@ -595,7 +620,8 @@ subroutine get_command_line_settings(cmd_settings)
             & build_tests=.true., &
             & name=names, &
             & runner=val_runner, &
-            & verbose=lget('verbose') )
+            & runner_args=val_runner_args, &
+            & verbose=lget('verbose'))
 
         case('update')
             call set_args(common_args // ' --fetch-only F --clean F --dump " " ', &
@@ -655,15 +681,14 @@ subroutine get_command_line_settings(cmd_settings)
             allocate(fpm_clean_settings :: cmd_settings)
             call get_current_directory(working_dir, error)
             cmd_settings=fpm_clean_settings( &
-            &   is_unix=is_unix,             &
-            &   calling_dir=working_dir,     &
             &   clean_skip=lget('skip'),     &
-                clean_call=lget('all'))
+            &   clean_call=lget('all'))
 
         case('publish')
             call set_args(common_args // compiler_args //'&
             & --show-package-version F &
-            & --show-form-data F &
+            & --show-upload-data F &
+            & --dry-run F &
             & --token " " &
             & --list F &
             & --show-model F &
@@ -675,10 +700,13 @@ subroutine get_command_line_settings(cmd_settings)
             c_compiler = sget('c-compiler')
             cxx_compiler = sget('cxx-compiler')
             archiver = sget('archiver')
+            token_s = sget('token')
 
-            allocate(publish_settings, source=fpm_publish_settings( &
+            allocate(fpm_publish_settings :: cmd_settings)
+            cmd_settings = fpm_publish_settings( &
             & show_package_version = lget('show-package-version'), &
-            & show_form_data = lget('show-form-data'), &
+            & show_upload_data = lget('show-upload-data'), &
+            & is_dry_run = lget('dry-run'), &
             & profile=val_profile,&
             & prune=.not.lget('no-prune'), &
             & compiler=val_compiler, &
@@ -692,9 +720,8 @@ subroutine get_command_line_settings(cmd_settings)
             & list=lget('list'),&
             & show_model=lget('show-model'),&
             & build_tests=lget('tests'),&
-            & verbose=lget('verbose')))
-            call get_char_arg(publish_settings%token, 'token')
-            call move_alloc(publish_settings, cmd_settings)
+            & verbose=lget('verbose'),&
+            & token=token_s)
 
         case default
 
@@ -796,7 +823,8 @@ subroutine set_help()
    ' install [--profile PROF] [--flag FFLAGS] [--no-rebuild] [--prefix PATH]        ', &
    '         [options]                                                              ', &
    ' clean [--skip] [--all]                                                         ', &
-   ' publish [--show-package-version] [--show-form-data] [--token TOKEN]            ', &
+   ' publish [--token TOKEN] [--show-package-version] [--show-upload-data]          ', &
+   '         [--dry-run] [--verbose]                                                ', &
    ' ']
     help_usage=[character(len=80) :: &
     '' ]
@@ -806,7 +834,7 @@ subroutine set_help()
    '                 executables.                                                   ', &
    '                                                                                ', &
    'SYNOPSIS                                                                        ', &
-   '   fpm run|test --runner CMD ... -- SUFFIX_OPTIONS                              ', &
+   '   fpm run|test --runner CMD ... --runner-args ARGS -- SUFFIX_OPTIONS           ', &
    '                                                                                ', &
    'DESCRIPTION                                                                     ', &
    '   The --runner option allows specifying a program to launch                    ', &
@@ -822,8 +850,11 @@ subroutine set_help()
    '               Available for both the "run" and "test" subcommands.             ', &
    '               If the keyword is specified without a value the default command  ', &
    '               is "echo".                                                       ', &
+   ' --runner-args "args"    an additional option to pass command-line arguments    ', &
+   '               to the runner command, instead of to the fpm app.                ', &
    ' -- SUFFIX_OPTIONS  additional options to suffix the command CMD and executable ', &
-   '                    file names with.                                            ', &
+   '                    file names with. These options are passed as command-line   ', &
+   '                    arguments to the app.                                       ', &
    'EXAMPLES                                                                        ', &
    '   Use cases for ''fpm run|test --runner "CMD"'' include employing                ', &
    '   the following common GNU/Linux and Unix commands:                            ', &
@@ -852,6 +883,7 @@ subroutine set_help()
    '                                                                                ', &
    '  fpm test --runner gdb                                                         ', &
    '  fpm run --runner "tar cvfz $HOME/bundle.tgz"                                  ', &
+   '  fpm run --runner "mpiexec" --runner-args "-np 12"                             ', &
    '  fpm run --runner ldd                                                          ', &
    '  fpm run --runner strip                                                        ', &
    '  fpm run --runner ''cp -t /usr/local/bin''                                       ', &
@@ -920,7 +952,8 @@ subroutine set_help()
     '    install [--profile PROF] [--flag FFLAGS] [--no-rebuild] [--prefix PATH]     ', &
     '            [options]                                                           ', &
     '    clean [--skip] [--all]                                                      ', &
-    '    publish [--show-package-version] [--show-form-data] [--token TOKEN]         ', &
+    '    publish [--token TOKEN] [--show-package-version] [--show-upload-data]       ', &
+    '            [--dry-run] [--verbose]                                             ', &
     '                                                                                ', &
     'SUBCOMMAND OPTIONS                                                              ', &
     ' -C, --directory PATH', &
@@ -1000,7 +1033,7 @@ subroutine set_help()
     ' list(1) - list summary of fpm(1) subcommands                          ', &
     '                                                                       ', &
     'SYNOPSIS                                                               ', &
-    ' fpm list [-list]                                                      ', &
+    ' fpm list                                                              ', &
     '                                                                       ', &
     ' fpm list --help|--version                                             ', &
     '                                                                       ', &
@@ -1170,13 +1203,15 @@ subroutine set_help()
     help_new=[character(len=80) ::                                             &
     'NAME                                                                   ', &
     ' new(1) - the fpm(1) subcommand to initialize a new project            ', &
+    '                                                                       ', &
     'SYNOPSIS                                                               ', &
-    '  fpm new NAME [[--lib|--src] [--app] [--test] [--example]]|           ', &
-    '      [--full|--bare][--backfill]                                      ', &
+    ' fpm new NAME [[--lib|--src] [--app] [--test] [--example]]|            ', &
+    '              [--full|--bare][--backfill]                              ', &
     ' fpm new --help|--version                                              ', &
     '                                                                       ', &
     'DESCRIPTION                                                            ', &
     ' "fpm new" creates and populates a new programming project directory.  ', &
+    '                                                                       ', &
     ' It                                                                    ', &
     '   o creates a directory with the specified name                       ', &
     '   o runs the command "git init" in that directory                     ', &
@@ -1407,16 +1442,47 @@ subroutine set_help()
     ' publish(1) - publish package to the registry', &
     '', &
     'SYNOPSIS', &
-    ' fpm publish [--token TOKEN]', &
+    ' fpm publish [--token TOKEN] [--show-package-version] [--show-upload-data]', &
+    '             [--dry-run] [--verbose]                                      ', &
+    '', &
+    ' fpm publish --help|--version', &
     '', &
     'DESCRIPTION', &
-    ' Collect relevant source files and upload package to the registry.', &
-    ' It is mandatory to provide a token. The token can be generated on the', &
-    ' registry website and will be linked to your username and namespace.', &
+    ' Follow the steps to create a tarball and upload a package to the registry:', &
+    '', &
+    '  1. Register on the website (https://registry-frontend.vercel.app/).', &
+    '  2. Create a namespace. Uploaded packages must be assigned to a unique', &
+    '     namespace to avoid conflicts among packages with similar names. A', &
+    '     namespace can accommodate multiple packages.', &
+    '  3. Create a token for that namespace. A token is linked to your username', &
+    '     and is used to authenticate you during the upload process. Do not share', &
+    '     the token with others.', &
+    '  4. Run fpm publish --token TOKEN to upload the package to the registry.', &
+    '     But be aware that the upload is permanent. An uploaded package cannot be', &
+    '     deleted.', &
+    '', &
+    ' See documentation for more information regarding package upload and usage:', &
+    '', &
+    ' Package upload:', &
+    ' https://fpm.fortran-lang.org/en/spec/publish.html', &
+    '', &
+    ' Package usage:', &
+    ' https://fpm.fortran-lang.org/en/spec/manifest.html#dependencies-from-a-registry', &
     '', &
     'OPTIONS', &
     ' --show-package-version   show package version without publishing', &
-    ' --show-form-data         show sent form data without publishing', &
+    ' --show-upload-data       show upload data without publishing', &
+    ' --dry-run                perform dry run without publishing', &
+    ' --help                   print this help and exit', &
+    ' --version                print program version information and exit', &
+    ' --verbose                print more information', &
+    '', &
+    'EXAMPLES', &
+    '', &
+    ' fpm publish --show-package-version    # show package version without publishing', &
+    ' fpm publish --show-upload-data        # show upload data without publishing', &
+    ' fpm publish --token TOKEN --dry-run   # perform dry run without publishing', &
+    ' fpm publish --token TOKEN             # upload package to the registry', &
     '' ]
      end subroutine set_help
 
@@ -1440,4 +1506,20 @@ function get_fpm_env(env, default) result(val)
       val = get_env(fpm_prefix//env, default)
     end function get_fpm_env
 
+
+    !> Build a full runner command (executable + command-line arguments)
+    function runner_command(cmd) result(run_cmd)
+        class(fpm_run_settings), intent(in) :: cmd
+        character(len=:), allocatable :: run_cmd
+        !> Get executable
+        if (len_trim(cmd%runner)>0) then
+            run_cmd = trim(cmd%runner)
+        else
+            run_cmd = ''
+        end if
+        !> Append command-line arguments
+        if (len_trim(cmd%runner_args)>0) run_cmd = run_cmd//' '//trim(cmd%runner_args)
+    end function runner_command
+
+
 end module fpm_command_line
diff --git a/src/fpm_compiler.F90 b/src/fpm_compiler.F90
index 462f5ab946..3031d50d11 100644
--- a/src/fpm_compiler.F90
+++ b/src/fpm_compiler.F90
@@ -28,7 +28,6 @@
 module fpm_compiler
 use,intrinsic :: iso_fortran_env, only: stderr=>error_unit
 use fpm_environment, only: &
-        get_env, &
         get_os_type, &
         OS_LINUX, &
         OS_MACOS, &
@@ -109,8 +108,10 @@ module fpm_compiler
     procedure :: link
     !> Check whether compiler is recognized
     procedure :: is_unknown
-    !> Check whether compiler is Intel family
+    !> Check whether this is an Intel compiler
     procedure :: is_intel
+    !> Check whether this is a GNU compiler
+    procedure :: is_gnu
     !> Enumerate libraries, based on compiler and platform
     procedure :: enumerate_libraries
 
@@ -118,6 +119,8 @@ module fpm_compiler
     procedure :: serializable_is_same => compiler_is_same
     procedure :: dump_to_toml => compiler_dump
     procedure :: load_from_toml => compiler_load
+    !> Return compiler name
+    procedure :: name => compiler_name
 
 end type compiler_t
 
@@ -160,6 +163,7 @@ module fpm_compiler
     flag_gnu_check = " -fcheck=bounds -fcheck=array-temps", &
     flag_gnu_limit = " -fmax-errors=1", &
     flag_gnu_external = " -Wimplicit-interface", &
+    flag_gnu_openmp = " -fopenmp", &
     flag_gnu_no_implicit_typing = " -fimplicit-none", &
     flag_gnu_no_implicit_external = " -Werror=implicit-interface", &
     flag_gnu_free_form = " -ffree-form", &
@@ -171,6 +175,7 @@ module fpm_compiler
     flag_pgi_debug = " -g", &
     flag_pgi_check = " -Mbounds -Mchkptr -Mchkstk", &
     flag_pgi_warn = " -Minform=inform", &
+    flag_pgi_openmp = " -mp", &
     flag_pgi_free_form = " -Mfree", &
     flag_pgi_fixed_form = " -Mfixed"
 
@@ -182,28 +187,34 @@ module fpm_compiler
     flag_intel_warn = " -warn all", &
     flag_intel_check = " -check all", &
     flag_intel_debug = " -O0 -g", &
+    flag_intel_opt = " -O3", &
     flag_intel_fp = " -fp-model precise -pc64", &
     flag_intel_align = " -align all", &
     flag_intel_limit = " -error-limit 1", &
     flag_intel_pthread = " -reentrancy threaded", &
     flag_intel_nogen = " -nogen-interfaces", &
     flag_intel_byterecl = " -assume byterecl", &
+    flag_intel_openmp = " -qopenmp", &
     flag_intel_free_form = " -free", &
-    flag_intel_fixed_form = " -fixed"
+    flag_intel_fixed_form = " -fixed", &
+    flag_intel_standard_compliance = " -standard-semantics"
 
 character(*), parameter :: &
     flag_intel_backtrace_win = " /traceback", &
     flag_intel_warn_win = " /warn:all", &
     flag_intel_check_win = " /check:all", &
     flag_intel_debug_win = " /Od /Z7", &
+    flag_intel_opt_win = " /O3", &
     flag_intel_fp_win = " /fp:precise", &
     flag_intel_align_win = " /align:all", &
     flag_intel_limit_win = " /error-limit:1", &
     flag_intel_pthread_win = " /reentrancy:threaded", &
     flag_intel_nogen_win = " /nogen-interfaces", &
     flag_intel_byterecl_win = " /assume:byterecl", &
+    flag_intel_openmp_win = " /Qopenmp", &
     flag_intel_free_form_win = " /free", &
-    flag_intel_fixed_form_win = " /fixed"
+    flag_intel_fixed_form_win = " /fixed", &
+    flag_intel_standard_compliance_win = " /standard-semantics"
 
 character(*), parameter :: &
     flag_nag_coarray = " -coarray=single", &
@@ -212,17 +223,18 @@ module fpm_compiler
     flag_nag_debug = " -g -O0", &
     flag_nag_opt = " -O4", &
     flag_nag_backtrace = " -gline", &
+    flag_nag_openmp = " -openmp", &
     flag_nag_free_form = " -free", &
     flag_nag_fixed_form = " -fixed", &
     flag_nag_no_implicit_typing = " -u"
 
 character(*), parameter :: &
     flag_lfortran_opt = " --fast", &
+    flag_lfortran_openmp = " --openmp", &
     flag_lfortran_implicit_typing = " --implicit-typing", &
     flag_lfortran_implicit_external = " --allow-implicit-interface", &
     flag_lfortran_fixed_form = " --fixed-form"
 
-
 character(*), parameter :: &
     flag_cray_no_implicit_typing = " -dl", &
     flag_cray_implicit_typing = " -el", &
@@ -284,48 +296,58 @@ subroutine get_release_compile_flags(id, flags)
 
     case(id_intel_classic_nix)
         flags = &
+            flag_intel_opt//&
             flag_intel_fp//&
             flag_intel_align//&
             flag_intel_limit//&
             flag_intel_pthread//&
             flag_intel_nogen//&
-            flag_intel_byterecl
+            flag_intel_byterecl//&
+            flag_intel_standard_compliance
 
     case(id_intel_classic_mac)
         flags = &
+            flag_intel_opt//&
             flag_intel_fp//&
             flag_intel_align//&
             flag_intel_limit//&
             flag_intel_pthread//&
             flag_intel_nogen//&
-            flag_intel_byterecl
+            flag_intel_byterecl//&
+            flag_intel_standard_compliance
 
     case(id_intel_classic_windows)
         flags = &
-            & flag_intel_fp_win//&
+            flag_intel_opt_win//&
+            flag_intel_fp_win//&
             flag_intel_align_win//&
             flag_intel_limit_win//&
             flag_intel_pthread_win//&
             flag_intel_nogen_win//&
-            flag_intel_byterecl_win
+            flag_intel_byterecl_win//&
+            flag_intel_standard_compliance_win
 
     case(id_intel_llvm_nix)
         flags = &
+            flag_intel_opt//&
             flag_intel_fp//&
             flag_intel_align//&
             flag_intel_limit//&
             flag_intel_pthread//&
             flag_intel_nogen//&
-            flag_intel_byterecl
+            flag_intel_byterecl//&
+            flag_intel_standard_compliance
 
     case(id_intel_llvm_windows)
         flags = &
+            flag_intel_opt_win//&
             flag_intel_fp_win//&
             flag_intel_align_win//&
             flag_intel_limit_win//&
             flag_intel_pthread_win//&
             flag_intel_nogen_win//&
-            flag_intel_byterecl_win
+            flag_intel_byterecl_win//&
+            flag_intel_standard_compliance_win
 
     case(id_nag)
         flags = &
@@ -389,7 +411,9 @@ subroutine get_debug_compile_flags(id, flags)
             flag_intel_limit//&
             flag_intel_debug//&
             flag_intel_byterecl//&
+            flag_intel_standard_compliance//&
             flag_intel_backtrace
+
     case(id_intel_classic_mac)
         flags = &
             flag_intel_warn//&
@@ -397,6 +421,7 @@ subroutine get_debug_compile_flags(id, flags)
             flag_intel_limit//&
             flag_intel_debug//&
             flag_intel_byterecl//&
+            flag_intel_standard_compliance//&
             flag_intel_backtrace
     case(id_intel_classic_windows)
         flags = &
@@ -405,6 +430,7 @@ subroutine get_debug_compile_flags(id, flags)
             flag_intel_limit_win//&
             flag_intel_debug_win//&
             flag_intel_byterecl_win//&
+            flag_intel_standard_compliance_win//&
             flag_intel_backtrace_win
     case(id_intel_llvm_nix)
         flags = &
@@ -413,6 +439,7 @@ subroutine get_debug_compile_flags(id, flags)
             flag_intel_limit//&
             flag_intel_debug//&
             flag_intel_byterecl//&
+            flag_intel_standard_compliance//&
             flag_intel_backtrace
     case(id_intel_llvm_windows)
         flags = &
@@ -420,7 +447,8 @@ subroutine get_debug_compile_flags(id, flags)
             flag_intel_check_win//&
             flag_intel_limit_win//&
             flag_intel_debug_win//&
-            flag_intel_byterecl_win
+            flag_intel_byterecl_win//&
+            flag_intel_standard_compliance_win
     case(id_nag)
         flags = &
             flag_nag_debug//&
@@ -945,10 +973,15 @@ end function is_unknown
 
 pure logical function is_intel(self)
     class(compiler_t), intent(in) :: self
-    is_intel = any(self%id == [id_intel_classic_mac,id_intel_classic_nix,id_intel_classic_windows,&
-                               id_intel_llvm_nix,id_intel_llvm_unknown,id_intel_llvm_windows])
+    is_intel = any(self%id == [id_intel_classic_nix,id_intel_classic_mac,id_intel_classic_windows, &
+                               id_intel_llvm_nix,id_intel_llvm_windows,id_intel_llvm_unknown])
 end function is_intel
 
+pure logical function is_gnu(self)
+    class(compiler_t), intent(in) :: self
+    is_gnu = any(self%id == [id_f95,id_gcc,id_caf])
+end function is_gnu
+
 !>
 !> Enumerate libraries, based on compiler and platform
 !>
@@ -1357,6 +1390,36 @@ subroutine compiler_load(self, table, error)
 
 end subroutine compiler_load
 
+!> Return a compiler name string
+pure function compiler_name(self) result(name)
+   !> Instance of the compiler object
+   class(compiler_t), intent(in) :: self
+   !> Representation as string
+   character(len=:), allocatable :: name
+
+   select case (self%id)
+       case(id_gcc); name = "gfortran"
+       case(id_f95); name = "f95"
+       case(id_caf); name = "caf"
+       case(id_intel_classic_nix);     name = "ifort"
+       case(id_intel_classic_mac);     name = "ifort"
+       case(id_intel_classic_windows); name = "ifort"
+       case(id_intel_llvm_nix);     name = "ifx"
+       case(id_intel_llvm_windows); name = "ifx"
+       case(id_intel_llvm_unknown); name = "ifx"
+       case(id_pgi);       name = "pgfortran"
+       case(id_nvhpc);     name = "nvfortran"
+       case(id_nag);       name = "nagfor"
+       case(id_flang);     name = "flang"
+       case(id_flang_new); name = "flang-new"
+       case(id_f18);       name = "f18"
+       case(id_ibmxl);     name = "xlf90"
+       case(id_cray);      name = "crayftn"
+       case(id_lahey);     name = "lfc"
+       case(id_lfortran);  name = "lFortran"
+       case default;       name = "invalid/unknown"
+   end select
+end function compiler_name
 
 
 
diff --git a/src/fpm_filesystem.F90 b/src/fpm_filesystem.F90
index c7b12a8b5e..177ee85fea 100644
--- a/src/fpm_filesystem.F90
+++ b/src/fpm_filesystem.F90
@@ -6,7 +6,7 @@ module fpm_filesystem
                                OS_UNKNOWN, OS_LINUX, OS_MACOS, OS_WINDOWS, &
                                OS_CYGWIN, OS_SOLARIS, OS_FREEBSD, OS_OPENBSD
     use fpm_environment, only: separator, get_env, os_is_unix
-    use fpm_strings, only: f_string, replace, string_t, split, notabs, str_begins_with_str
+    use fpm_strings, only: f_string, replace, string_t, split, dilate, str_begins_with_str
     use iso_c_binding, only: c_char, c_ptr, c_int, c_null_char, c_associated, c_f_pointer
     use fpm_error, only : fpm_stop, error_t, fatal_error
     implicit none
@@ -14,9 +14,7 @@ module fpm_filesystem
     public :: basename, canon_path, dirname, is_dir, join_path, number_of_rows, list_files, get_local_prefix, &
             mkdir, exists, get_temp_filename, windows_path, unix_path, getline, delete_file, fileopen, fileclose, &
             filewrite, warnwrite, parent_dir, is_hidden_file, read_lines, read_lines_expanded, which, run, &
-            LINE_BUFFER_LEN, os_delete_dir, is_absolute_path, env_variable, get_home, get_tmp_directory, &
-            execute_and_read_output
-    integer, parameter :: LINE_BUFFER_LEN = 1000
+            os_delete_dir, is_absolute_path, get_home, execute_and_read_output, get_dos_path
 
 #ifndef FPM_BOOTSTRAP
     interface
@@ -54,29 +52,6 @@ end function c_is_dir
 
 contains
 
-
-!> return value of environment variable
-subroutine env_variable(var, name)
-   character(len=:), allocatable, intent(out) :: var
-   character(len=*), intent(in) :: name
-   integer :: length, stat
-
-   call get_environment_variable(name, length=length, status=stat)
-   if (stat /= 0) return
-
-   allocate(character(len=length) :: var)
-
-   if (length > 0) then
-      call get_environment_variable(name, var, status=stat)
-      if (stat /= 0) then
-         deallocate(var)
-         return
-      end if
-   end if
-
-end subroutine env_variable
-
-
 !> Extract filename from path with/without suffix
 function basename(path,suffix) result (base)
 
@@ -332,14 +307,13 @@ function read_lines_expanded(fh) result(lines)
     type(string_t), allocatable :: lines(:)
 
     integer :: i
-    integer :: ilen
-    character(LINE_BUFFER_LEN) :: line_buffer_read, line_buffer_expanded
+    integer :: iostat
+    character(len=:),allocatable :: line_buffer_read
 
     allocate(lines(number_of_rows(fh)))
     do i = 1, size(lines)
-        read(fh, '(A)') line_buffer_read
-        call notabs(line_buffer_read, line_buffer_expanded, ilen)
-        lines(i)%s = trim(line_buffer_expanded)
+        call getline(fh, line_buffer_read, iostat)
+        lines(i)%s = dilate(line_buffer_read)
     end do
 
 end function read_lines_expanded
@@ -350,12 +324,11 @@ function read_lines(fh) result(lines)
     type(string_t), allocatable :: lines(:)
 
     integer :: i
-    character(LINE_BUFFER_LEN) :: line_buffer
+    integer :: iostat
 
     allocate(lines(number_of_rows(fh)))
     do i = 1, size(lines)
-        read(fh, '(A)') line_buffer
-        lines(i)%s = trim(line_buffer)
+        call getline(fh, lines(i)%s, iostat)
     end do
 
 end function read_lines
@@ -543,6 +516,12 @@ end subroutine list_files
 logical function exists(filename) result(r)
     character(len=*), intent(in) :: filename
     inquire(file=filename, exist=r)
+
+    !> Directories are not files for the Intel compilers. If so, also use this compiler-dependent extension
+#if defined(__INTEL_COMPILER)
+    if (.not.r) inquire(directory=filename, exist=r)
+#endif
+
 end function
 
 
@@ -554,6 +533,7 @@ logical function exists(filename) result(r)
 function get_temp_filename() result(tempfile)
     !
     use iso_c_binding, only: c_ptr, C_NULL_PTR, c_f_pointer
+    integer, parameter :: MAX_FILENAME_LENGTH = 32768
     character(:), allocatable :: tempfile
 
     type(c_ptr) :: c_tempfile_ptr
@@ -576,7 +556,7 @@ end subroutine c_free
     end interface
 
     c_tempfile_ptr = c_tempnam(C_NULL_PTR, C_NULL_PTR)
-    call c_f_pointer(c_tempfile_ptr,c_tempfile,[LINE_BUFFER_LEN])
+    call c_f_pointer(c_tempfile_ptr,c_tempfile,[MAX_FILENAME_LENGTH])
 
     tempfile = f_string(c_tempfile)
 
@@ -622,8 +602,68 @@ function unix_path(path) result(nixpath)
 
 end function unix_path
 
-
-!> read a line of arbitrary length into a CHARACTER variable from the specified LUN
+!>AUTHOR: fpm(1) contributors
+!!LICENSE: MIT
+!>
+!!##NAME
+!!     getline(3f) - [M_io:READ] read a line of arbintrary length from specified
+!!     LUN into allocatable string (up to system line length limit)
+!!    (LICENSE:PD)
+!!
+!!##SYNTAX
+!!   subroutine getline(unit,line,iostat,iomsg)
+!!
+!!    integer,intent(in)                       :: unit
+!!    character(len=:),allocatable,intent(out) :: line
+!!    integer,intent(out)                      :: iostat
+!!    character(len=:), allocatable, optional  :: iomsg
+!!
+!!##DESCRIPTION
+!!    Read a line of any length up to programming environment maximum
+!!    line length. Requires Fortran 2003+.
+!!
+!!    It is primarily expected to be used when reading input which will
+!!    then be parsed or echoed.
+!!
+!!    The input file must have a PAD attribute of YES for the function
+!!    to work properly, which is typically true.
+!!
+!!    The simple use of a loop that repeatedly re-allocates a character
+!!    variable in addition to reading the input file one buffer at a
+!!    time could (depending on the programming environment used) be
+!!    inefficient, as it could reallocate and allocate memory used for
+!!    the output string with each buffer read.
+!!
+!!##OPTIONS
+!!    LINE    The line read when IOSTAT returns as zero.
+!!    LUN     LUN (Fortran logical I/O unit) number of file open and ready
+!!            to read.
+!!    IOSTAT  status returned by READ(IOSTAT=IOS). If not zero, an error
+!!            occurred or an end-of-file or end-of-record was encountered.
+!!    IOMSG   error message returned by system when IOSTAT is not zero.
+!!
+!!##EXAMPLE
+!!
+!!   Sample program:
+!!
+!!    program demo_getline
+!!    use,intrinsic :: iso_fortran_env, only : stdin=>input_unit
+!!    use,intrinsic :: iso_fortran_env, only : iostat_end
+!!    use FPM_filesystem, only : getline
+!!    implicit none
+!!    integer :: iostat
+!!    character(len=:),allocatable :: line, iomsg
+!!       open(unit=stdin,pad='yes')
+!!       INFINITE: do 
+!!          call getline(stdin,line,iostat,iomsg)
+!!          if(iostat /= 0) exit INFINITE
+!!          write(*,'(a)')'['//line//']'
+!!       enddo INFINITE
+!!       if(iostat /= iostat_end)then
+!!          write(*,*)'error reading input:',iomsg
+!!       endif
+!!    end program demo_getline
+!!
 subroutine getline(unit, line, iostat, iomsg)
 
     !> Formatted IO unit
@@ -638,8 +678,9 @@ subroutine getline(unit, line, iostat, iomsg)
     !> Error message
     character(len=:), allocatable, optional :: iomsg
 
-    character(len=LINE_BUFFER_LEN) :: buffer
-    character(len=LINE_BUFFER_LEN) :: msg
+    integer, parameter :: BUFFER_SIZE = 32768
+    character(len=BUFFER_SIZE)       :: buffer
+    character(len=256)               :: msg
     integer :: size
     integer :: stat
 
@@ -768,31 +809,32 @@ subroutine filewrite(filename,filedata)
 
 end subroutine filewrite
 
-function which(command) result(pathname)
+!>AUTHOR: John S. Urban
+!!LICENSE: Public Domain
 !>
-!!##NAME
+!!##Name
 !!     which(3f) - [M_io:ENVIRONMENT] given a command name find the pathname by searching
 !!                 the directories in the environment variable $PATH
 !!     (LICENSE:PD)
 !!
-!!##SYNTAX
+!!##Syntax
 !!   function which(command) result(pathname)
 !!
 !!    character(len=*),intent(in)  :: command
 !!    character(len=:),allocatable :: pathname
 !!
-!!##DESCRIPTION
+!!##Description
 !!    Given a command name find the first file with that name in the directories
 !!    specified by the environment variable $PATH.
 !!
-!!##OPTIONS
+!!##options
 !!    COMMAND   the command to search for
 !!
-!!##RETURNS
+!!##Returns
 !!    PATHNAME  the first pathname found in the current user path. Returns blank
 !!              if the command is not found.
 !!
-!!##EXAMPLE
+!!##Example
 !!
 !!   Sample program:
 !!
@@ -806,11 +848,7 @@ function which(command) result(pathname)
 !!        write(*,*)'install is ',which('install')
 !!     end program demo_which
 !!
-!!##AUTHOR
-!!    John S. Urban
-!!##LICENSE
-!!    Public Domain
-
+function which(command) result(pathname)
 character(len=*),intent(in)     :: command
 character(len=:),allocatable    :: pathname, checkon, paths(:), exts(:)
 integer                         :: i, j
@@ -848,8 +886,66 @@ function which(command) result(pathname)
    enddo SEARCH
 end function which
 
-!> echo command string and pass it to the system for execution
-!call run(cmd,echo=.false.,exitstat=exitstat,verbose=.false.,redirect='')
+!>AUTHOR: fpm(1) contributors
+!!LICENSE: MIT
+!>
+!!##Name
+!!    run(3f) -  execute specified system command and selectively echo
+!!    command and output to a file and/or stdout.
+!!    (LICENSE:MIT)
+!!
+!!##Syntax
+!!    subroutine run(cmd,echo,exitstat,verbose,redirect)
+!!
+!!     character(len=*), intent(in)       :: cmd
+!!     logical,intent(in),optional        :: echo
+!!     integer, intent(out),optional      :: exitstat
+!!     logical, intent(in), optional      :: verbose
+!!     character(*), intent(in), optional :: redirect
+!!
+!!##Description
+!!   Execute the specified system command. Optionally
+!!
+!!   +  echo the command before execution
+!!   +  return the system exit status of the command.
+!!   +  redirect the output of the command to a file.
+!!   +  echo command output to stdout
+!!
+!!   Calling run(3f) is preferred to direct calls to
+!!   execute_command_line(3f) in the fpm(1) source to provide a standard
+!!   interface where output modes can be specified.
+!!
+!!##Options
+!!    CMD       System command to execute
+!!    ECHO      Whether to echo the command being executed or not
+!!              Defaults to .TRUE. .
+!!    VERBOSE   Whether to redirect the command output to a null device or not
+!!              Defaults to .TRUE. .
+!!    REDIRECT  Filename to redirect stdout and stderr of the command into.
+!!              If generated it is closed before run(3f) returns.
+!!    EXITSTAT  The system exit status of the command when supported by
+!!              the system. If not present and a non-zero status is
+!!              generated program termination occurs.
+!!
+!!##Example
+!!
+!!   Sample program:
+!!
+!!   Checking the error message and counting lines:
+!!
+!!     program demo_run
+!!     use fpm_filesystem, only : run
+!!     implicit none
+!!     logical,parameter :: T=.true., F=.false.
+!!     integer :: exitstat
+!!     character(len=:),allocatable :: cmd
+!!        cmd='ls -ltrasd *.md'
+!!        call run(cmd)
+!!        call run(cmd,exitstat=exitstat)
+!!        call run(cmd,echo=F)
+!!        call run(cmd,verbose=F)
+!!     end program demo_run
+!!
 subroutine run(cmd,echo,exitstat,verbose,redirect)
     character(len=*), intent(in) :: cmd
     logical,intent(in),optional  :: echo
@@ -956,15 +1052,15 @@ function get_local_prefix(os) result(prefix)
         character(len=:), allocatable :: home
 
         if (os_is_unix(os)) then
-            call env_variable(home, "HOME")
-            if (allocated(home)) then
+            home=get_env('HOME','')
+            if (home /= '' ) then
                 prefix = join_path(home, ".local")
             else
                 prefix = default_prefix_unix
             end if
         else
-            call env_variable(home, "APPDATA")
-            if (allocated(home)) then
+            home=get_env('APPDATA','')
+            if (home /= '' ) then
                 prefix = join_path(home, "local")
             else
                 prefix = default_prefix_win
@@ -1007,14 +1103,14 @@ subroutine get_home(home, error)
         type(error_t), allocatable, intent(out) :: error
 
         if (os_is_unix()) then
-            call env_variable(home, 'HOME')
-            if (.not. allocated(home)) then
+            home=get_env('HOME','')
+            if ( home == '' ) then
                 call fatal_error(error, "Couldn't retrieve 'HOME' variable")
                 return
             end if
         else
-            call env_variable(home, 'USERPROFILE')
-            if (.not. allocated(home)) then
+            home=get_env('USERPROFILE','')
+            if ( home == '' ) then
                 call fatal_error(error, "Couldn't retrieve '%USERPROFILE%' variable")
                 return
             end if
@@ -1022,64 +1118,103 @@ subroutine get_home(home, error)
     end subroutine get_home
 
     !> Execute command line and return output as a string.
-    subroutine execute_and_read_output(cmd, output, error, exitstat)
+    subroutine execute_and_read_output(cmd, output, error, verbose)
         !> Command to execute.
         character(len=*), intent(in) :: cmd
         !> Command line output.
         character(len=:), allocatable, intent(out) :: output
         !> Error to handle.
         type(error_t), allocatable, intent(out) :: error
-        !> Can optionally used for error handling.
-        integer, intent(out), optional :: exitstat
+        !> Print additional information if true.
+        logical, intent(in), optional :: verbose
 
-        integer :: cmdstat, unit, stat = 0
-        character(len=:), allocatable :: cmdmsg, tmp_path
-        character(len=1000) :: output_line
+        integer :: exitstat, unit, stat
+        character(len=:), allocatable :: cmdmsg, tmp_file, output_line
+        logical :: is_verbose
 
-        call get_tmp_directory(tmp_path, error)
-        if (allocated(error)) return
+        if (present(verbose)) then
+          is_verbose = verbose
+        else
+          is_verbose = .false.
+        end if
 
-        if (.not. exists(tmp_path)) call mkdir(tmp_path)
-        tmp_path = join_path(tmp_path, 'command_line_output')
-        call delete_file(tmp_path)
-        call filewrite(tmp_path, [''])
+        tmp_file = get_temp_filename()
 
-        call execute_command_line(cmd//' > '//tmp_path, exitstat=exitstat, cmdstat=cmdstat)
-        if (cmdstat /= 0) call fpm_stop(1,'*run*: '//"Command failed: '"//cmd//"'. Message: '"//trim(cmdmsg)//"'.")
+        call run(cmd//' > '//tmp_file, exitstat=exitstat, echo=is_verbose)
+        if (exitstat /= 0) call fatal_error(error, '*run*: '//"Command failed: '"//cmd//"'. Message: '"//trim(cmdmsg)//"'.")
 
-        open(unit, file=tmp_path, action='read', status='old')
+        open(newunit=unit, file=tmp_file, action='read', status='old')
         output = ''
         do
-          read(unit, *, iostat=stat) output_line
-          if (stat /= 0) exit
-          output = output//trim(output_line)//' '
+           call getline(unit, output_line, stat)
+           if (stat /= 0) exit
+           output = output//output_line//' '
         end do
+        if (is_verbose) print *, output
         close(unit, status='delete')
     end
 
-    !> Get system-dependent tmp directory.
-    subroutine get_tmp_directory(tmp_dir, error)
-        !> System-dependant tmp directory.
-        character(len=:), allocatable, intent(out) :: tmp_dir
-        !> Error to handle.
+    !> Ensure a windows path is converted to an 8.3 DOS path if it contains spaces
+    function get_dos_path(path,error)
+        character(len=*), intent(in) :: path
         type(error_t), allocatable, intent(out) :: error
+        character(len=:), allocatable :: get_dos_path
 
-        tmp_dir = get_env('TMPDIR', '')
-        if (tmp_dir /= '') then
-          tmp_dir = tmp_dir//'fpm'; return
-        end if
+        character(:), allocatable :: redirect,screen_output,line
+        integer :: stat,cmdstat,iunit,last
 
-        tmp_dir = get_env('TMP', '')
-        if (tmp_dir /= '') then
-          tmp_dir = tmp_dir//'fpm'; return
+        ! Non-Windows OS
+        if (get_os_type()/=OS_WINDOWS) then
+            get_dos_path = path
+            return
         end if
 
-        tmp_dir = get_env('TEMP', '')
-        if (tmp_dir /= '') then
-          tmp_dir = tmp_dir//'fpm'; return
-        end if
+        ! Trim path first
+        get_dos_path = trim(path)
 
-        call fatal_error(error, "Couldn't determine system temporary directory.")
-    end
+        !> No need to convert if there are no spaces
+        has_spaces: if (scan(get_dos_path,' ')>0) then
+
+            redirect = get_temp_filename()
+            call execute_command_line('cmd /c for %A in ("'//path//'") do @echo %~sA >'//redirect//' 2>&1',&
+                                      exitstat=stat,cmdstat=cmdstat)
+
+            !> Read screen output
+            command_OK: if (cmdstat==0 .and. stat==0) then
+
+                allocate(character(len=0) :: screen_output)
+                open(newunit=iunit,file=redirect,status='old',iostat=stat)
+                if (stat == 0)then
+
+                   do
+                       call getline(iunit, line, stat)
+                       if (stat /= 0) exit
+                       screen_output = screen_output//line//' '
+                   end do
+
+                   ! Close and delete file
+                   close(iunit,status='delete')
+
+                else
+                   call fatal_error(error,'cannot read temporary file from successful DOS path evaluation')
+                   return
+                endif
+
+            else command_OK
+
+                call fatal_error(error,'unsuccessful Windows->DOS path command')
+                return
+
+            end if command_OK
+
+            get_dos_path = trim(adjustl(screen_output))
+
+        endif has_spaces
+
+        !> Ensure there are no trailing slashes
+        last = len_trim(get_dos_path)
+        if (last>1 .and. get_dos_path(last:last)=='/' .or. get_dos_path(last:last)=='\') get_dos_path = get_dos_path(1:last-1)
+
+    end function get_dos_path
 
 end module fpm_filesystem
diff --git a/src/fpm_meta.f90 b/src/fpm_meta.f90
new file mode 100644
index 0000000000..827af3ca3c
--- /dev/null
+++ b/src/fpm_meta.f90
@@ -0,0 +1,1601 @@
+!># The fpm meta-package model
+!>
+!> This is a wrapper data type that encapsulate all pre-processing information
+!> (compiler flags, linker libraries, etc.) required to correctly enable a package
+!> to use a core library.
+!>        
+!>
+!>### Available core libraries   
+!>
+!> - OpenMP
+!> - MPI
+!> - fortran-lang stdlib
+!> - fortran-lang minpack
+!> 
+!>
+!> @note Core libraries are enabled in the [build] section of the fpm.toml manifest
+!>
+!>
+module fpm_meta
+use fpm_strings, only: string_t, len_trim, remove_newline_characters
+use fpm_error, only: error_t, fatal_error, syntax_error, fpm_stop
+use fpm_compiler
+use fpm_model
+use fpm_command_line
+use fpm_manifest_dependency, only: dependency_config_t
+use fpm_git, only : git_target_branch, git_target_tag
+use fpm_manifest, only: package_config_t
+use fpm_environment, only: get_env,os_is_unix
+use fpm_filesystem, only: run, get_temp_filename, getline, exists, canon_path, is_dir, get_dos_path
+use fpm_versioning, only: version_t, new_version, regex_version_from_text
+use fpm_os, only: get_absolute_path
+use iso_fortran_env, only: stdout => output_unit
+
+implicit none
+
+private
+
+public :: resolve_metapackages
+
+!> Type for describing a source file
+type, public :: metapackage_t
+
+    !> Package version (if supported)
+    type(version_t), allocatable :: version
+
+    logical :: has_link_libraries   = .false.
+    logical :: has_link_flags       = .false.
+    logical :: has_build_flags      = .false.
+    logical :: has_fortran_flags    = .false.
+    logical :: has_c_flags          = .false.
+    logical :: has_cxx_flags        = .false.
+    logical :: has_include_dirs     = .false.
+    logical :: has_dependencies     = .false.
+    logical :: has_run_command      = .false.
+    logical :: has_external_modules = .false.
+
+    !> List of compiler flags and options to be added
+    type(string_t) :: flags
+    type(string_t) :: fflags
+    type(string_t) :: cflags
+    type(string_t) :: cxxflags
+    type(string_t) :: link_flags
+    type(string_t) :: run_command
+    type(string_t), allocatable :: incl_dirs(:)
+    type(string_t), allocatable :: link_libs(:)
+    type(string_t), allocatable :: external_modules(:)
+
+    !> Special fortran features
+    type(fortran_features_t), allocatable :: fortran
+
+    !> List of Development dependency meta data.
+    !> Metapackage dependencies are never exported from the model
+    type(dependency_config_t), allocatable :: dependency(:)
+
+    contains
+
+       !> Clean metapackage structure
+       procedure :: destroy
+
+       !> Initialize the metapackage structure from its given name
+       procedure :: new => init_from_name
+
+       !> Add metapackage dependencies to the model
+       procedure, private :: resolve_cmd
+       procedure, private :: resolve_model
+       procedure, private :: resolve_package_config
+       generic :: resolve => resolve_cmd,resolve_model,resolve_package_config
+
+end type metapackage_t
+
+interface resolve_metapackages
+    module procedure resolve_metapackage_model
+end interface resolve_metapackages
+
+integer, parameter :: MPI_TYPE_NONE    = 0
+integer, parameter :: MPI_TYPE_OPENMPI = 1
+integer, parameter :: MPI_TYPE_MPICH   = 2
+integer, parameter :: MPI_TYPE_INTEL   = 3
+integer, parameter :: MPI_TYPE_MSMPI   = 4
+public             :: MPI_TYPE_NAME
+
+!> Debugging information
+logical, parameter, private :: verbose = .false.
+
+integer, parameter, private :: LANG_FORTRAN = 1
+integer, parameter, private :: LANG_C       = 2
+integer, parameter, private :: LANG_CXX     = 3
+
+contains
+
+!> Return a name for the MPI library
+pure function MPI_TYPE_NAME(mpilib) result(name)
+   integer, intent(in) :: mpilib
+   character(len=:), allocatable :: name
+   select case (mpilib)
+      case (MPI_TYPE_NONE);    name = "none"
+      case (MPI_TYPE_OPENMPI); name = "OpenMPI"
+      case (MPI_TYPE_MPICH);   name = "MPICH"
+      case (MPI_TYPE_INTEL);   name = "INTELMPI"
+      case (MPI_TYPE_MSMPI);   name = "MS-MPI"
+      case default;            name = "UNKNOWN"
+   end select
+end function MPI_TYPE_NAME
+
+!> Clean the metapackage structure
+elemental subroutine destroy(this)
+   class(metapackage_t), intent(inout) :: this
+
+   this%has_link_libraries   = .false.
+   this%has_link_flags       = .false.
+   this%has_build_flags      = .false.
+   this%has_fortran_flags    = .false.
+   this%has_c_flags          = .false.
+   this%has_cxx_flags        = .false.
+   this%has_include_dirs     = .false.
+   this%has_dependencies     = .false.
+   this%has_run_command      = .false.
+   this%has_external_modules = .false.
+
+   if (allocated(this%fortran)) deallocate(this%fortran)
+   if (allocated(this%version)) deallocate(this%version)
+   if (allocated(this%flags%s)) deallocate(this%flags%s)
+   if (allocated(this%fflags%s)) deallocate(this%fflags%s)
+   if (allocated(this%cflags%s)) deallocate(this%cflags%s)
+   if (allocated(this%cxxflags%s)) deallocate(this%cxxflags%s)
+   if (allocated(this%link_flags%s)) deallocate(this%link_flags%s)
+   if (allocated(this%run_command%s)) deallocate(this%run_command%s)
+   if (allocated(this%link_libs)) deallocate(this%link_libs)
+   if (allocated(this%dependency)) deallocate(this%dependency)
+   if (allocated(this%incl_dirs)) deallocate(this%incl_dirs)
+   if (allocated(this%external_modules)) deallocate(this%external_modules)
+
+end subroutine destroy
+
+!> Initialize a metapackage from the given name
+subroutine init_from_name(this,name,compiler,error)
+    class(metapackage_t), intent(inout) :: this
+    character(*), intent(in) :: name
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+    !> Initialize metapackage by name
+    select case(name)
+        case("openmp");  call init_openmp (this,compiler,error)
+        case("stdlib");  call init_stdlib (this,compiler,error)
+        case("minpack"); call init_minpack(this,compiler,error)
+        case("mpi");     call init_mpi    (this,compiler,error)
+        case default
+            call syntax_error(error, "Package "//name//" is not supported in [metapackages]")
+            return
+    end select
+
+end subroutine init_from_name
+
+!> Initialize OpenMP metapackage for the current system
+subroutine init_openmp(this,compiler,error)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+    !> Cleanup
+    call destroy(this)
+
+    !> OpenMP has compiler flags
+    this%has_build_flags = .true.
+    this%has_link_flags  = .true.
+
+    !> OpenMP flags should be added to
+    which_compiler: select case (compiler%id)
+       case (id_gcc,id_f95)
+            this%flags      = string_t(flag_gnu_openmp)
+            this%link_flags = string_t(flag_gnu_openmp)
+
+       case (id_intel_classic_windows,id_intel_llvm_windows)
+            this%flags      = string_t(flag_intel_openmp_win)
+            this%link_flags = string_t(flag_intel_openmp_win)
+
+       case (id_intel_classic_nix,id_intel_classic_mac,&
+             id_intel_llvm_nix)
+            this%flags      = string_t(flag_intel_openmp)
+            this%link_flags = string_t(flag_intel_openmp)
+
+       case (id_pgi,id_nvhpc)
+            this%flags      = string_t(flag_pgi_openmp)
+            this%link_flags = string_t(flag_pgi_openmp)
+
+       case (id_ibmxl)
+            this%flags      = string_t(" -qsmp=omp")
+            this%link_flags = string_t(" -qsmp=omp")
+
+       case (id_nag)
+            this%flags      = string_t(flag_nag_openmp)
+            this%link_flags = string_t(flag_nag_openmp)
+
+       case (id_lfortran)
+            this%flags      = string_t(flag_lfortran_openmp)
+            this%link_flags = string_t(flag_lfortran_openmp)
+
+       case default
+
+          call fatal_error(error,'openmp not supported on compiler '//compiler%name()//' yet')
+
+    end select which_compiler
+
+
+end subroutine init_openmp
+
+!> Initialize minpack metapackage for the current system
+subroutine init_minpack(this,compiler,error)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+    !> Cleanup
+    call destroy(this)
+
+    !> minpack is queried as a dependency from the official repository
+    this%has_dependencies = .true.
+
+    allocate(this%dependency(1))
+
+    !> 1) minpack. There are no true releases currently. Fetch HEAD
+    this%dependency(1)%name = "minpack"
+    this%dependency(1)%git = git_target_tag("https://github.com/fortran-lang/minpack", "v2.0.0-rc.1")
+    if (.not.allocated(this%dependency(1)%git)) then
+        call fatal_error(error,'cannot initialize git repo dependency for minpack metapackage')
+        return
+    end if
+
+end subroutine init_minpack
+
+!> Initialize stdlib metapackage for the current system
+subroutine init_stdlib(this,compiler,error)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+    !> Cleanup
+    call destroy(this)
+
+    !> Stdlib is queried as a dependency from the official repository
+    this%has_dependencies = .true.
+
+    allocate(this%dependency(2))
+
+    !> 1) Test-drive
+    this%dependency(1)%name = "test-drive"
+    this%dependency(1)%git = git_target_branch("https://github.com/fortran-lang/test-drive","v0.4.0")
+    if (.not.allocated(this%dependency(1)%git)) then
+        call fatal_error(error,'cannot initialize test-drive git dependency for stdlib metapackage')
+        return
+    end if
+
+    !> 2) stdlib
+    this%dependency(2)%name = "stdlib"
+    this%dependency(2)%git = git_target_branch("https://github.com/fortran-lang/stdlib","stdlib-fpm")
+    if (.not.allocated(this%dependency(2)%git)) then
+        call fatal_error(error,'cannot initialize git repo dependency for stdlib metapackage')
+        return
+    end if
+
+end subroutine init_stdlib
+
+! Resolve metapackage dependencies into the command line settings
+subroutine resolve_cmd(self,settings,error)
+    class(metapackage_t), intent(in) :: self
+    class(fpm_cmd_settings), intent(inout) :: settings
+    type(error_t), allocatable, intent(out) :: error
+
+    ! Add customize run commands
+    if (self%has_run_command) then
+
+        select type (cmd=>settings)
+           class is (fpm_run_settings) ! includes fpm_test_settings
+
+              ! Only override runner if user has not provided a custom one
+              if (.not.len_trim(cmd%runner)>0) cmd%runner = self%run_command%s
+
+        end select
+
+    endif
+
+end subroutine resolve_cmd
+
+! Resolve metapackage dependencies into the model
+subroutine resolve_model(self,model,error)
+    class(metapackage_t), intent(in) :: self
+    type(fpm_model_t), intent(inout) :: model
+    type(error_t), allocatable, intent(out) :: error
+
+    ! Add global build flags, to apply to all sources
+    if (self%has_build_flags) then
+        model%fortran_compile_flags = model%fortran_compile_flags//self%flags%s
+        model%c_compile_flags       = model%c_compile_flags//self%flags%s
+        model%cxx_compile_flags     = model%cxx_compile_flags//self%flags%s
+    endif
+
+    ! Add language-specific flags
+    if (self%has_fortran_flags) model%fortran_compile_flags = model%fortran_compile_flags//self%fflags%s
+    if (self%has_c_flags)       model%c_compile_flags       = model%c_compile_flags//self%cflags%s
+    if (self%has_cxx_flags)     model%cxx_compile_flags     = model%cxx_compile_flags//self%cxxflags%s
+
+    if (self%has_link_flags) then
+        model%link_flags            = model%link_flags//self%link_flags%s
+    end if
+
+    if (self%has_link_libraries) then
+        model%link_libraries        = [model%link_libraries,self%link_libs]
+    end if
+
+    if (self%has_include_dirs) then
+        model%include_dirs          = [model%include_dirs,self%incl_dirs]
+    end if
+
+    if (self%has_external_modules) then
+        model%external_modules      = [model%external_modules,self%external_modules]
+    end if
+
+end subroutine resolve_model
+
+subroutine resolve_package_config(self,package,error)
+    class(metapackage_t), intent(in) :: self
+    type(package_config_t), intent(inout) :: package
+    type(error_t), allocatable, intent(out) :: error
+
+    ! All metapackage dependencies are added as dev-dependencies,
+    ! as they may change if built upstream
+    if (self%has_dependencies) then
+        if (allocated(package%dev_dependency)) then
+           package%dev_dependency = [package%dev_dependency,self%dependency]
+        else
+           package%dev_dependency = self%dependency
+        end if
+    end if
+
+    ! Check if there are any special fortran requests which the package does not comply to
+    if (allocated(self%fortran)) then
+
+        if (self%fortran%implicit_external.neqv.package%fortran%implicit_external) then
+            call fatal_error(error,'metapackage fortran error: metapackage '// &
+                                   dn(self%fortran%implicit_external)//' require implicit-external, main package '//&
+                                   dn(package%fortran%implicit_external))
+            return
+        end if
+
+        if (self%fortran%implicit_typing.neqv.package%fortran%implicit_typing) then
+            call fatal_error(error,'metapackage fortran error: metapackage '// &
+                                   dn(self%fortran%implicit_external)//' require implicit-typing, main package '//&
+                                   dn(package%fortran%implicit_external))
+            return
+        end if
+
+    end if
+
+    contains
+
+    pure function dn(bool)
+       logical, intent(in) :: bool
+       character(len=:), allocatable :: dn
+       if (bool) then
+          dn = "does"
+       else
+          dn = "does not"
+       end if
+    end function dn
+
+
+end subroutine resolve_package_config
+
+! Add named metapackage dependency to the model
+subroutine add_metapackage_model(model,package,settings,name,error)
+    type(fpm_model_t), intent(inout) :: model
+    type(package_config_t), intent(inout) :: package
+    class(fpm_cmd_settings), intent(inout) :: settings
+    character(*), intent(in) :: name
+    type(error_t), allocatable, intent(out) :: error
+
+    type(metapackage_t) :: meta
+
+    !> Init metapackage
+    call meta%new(name,model%compiler,error)
+    if (allocated(error)) return
+
+    !> Add it into the model
+    call meta%resolve(model,error)
+    if (allocated(error)) return
+
+    !> Add it into the package
+    call meta%resolve(package,error)
+    if (allocated(error)) return
+
+    !> Add it into the settings
+    call meta%resolve(settings,error)
+    if (allocated(error)) return
+
+    ! If we need to run executables, there should be an MPI runner
+    if (name=="mpi") then
+        select type (settings)
+           class is (fpm_run_settings) ! run, test
+              if (.not.meta%has_run_command) &
+              call fatal_error(error,"cannot find a valid mpi runner on the local host")
+        end select
+    endif
+
+end subroutine add_metapackage_model
+
+!> Resolve all metapackages into the package config
+subroutine resolve_metapackage_model(model,package,settings,error)
+    type(fpm_model_t), intent(inout) :: model
+    type(package_config_t), intent(inout) :: package
+    class(fpm_build_settings), intent(inout) :: settings
+    type(error_t), allocatable, intent(out) :: error
+
+    ! Dependencies are added to the package config, so they're properly resolved
+    ! into the dependency tree later.
+    ! Flags are added to the model (whose compiler needs to be already initialized)
+    if (model%compiler%is_unknown()) then
+        call fatal_error(error,"compiler not initialized: cannot build metapackages")
+        return
+    end if
+
+    ! OpenMP
+    if (package%meta%openmp%on) then
+        call add_metapackage_model(model,package,settings,"openmp",error)
+        if (allocated(error)) return
+    endif
+
+    ! stdlib
+    if (package%meta%stdlib%on) then
+        call add_metapackage_model(model,package,settings,"stdlib",error)
+        if (allocated(error)) return
+    endif
+
+    ! stdlib
+    if (package%meta%minpack%on) then
+        call add_metapackage_model(model,package,settings,"minpack",error)
+        if (allocated(error)) return
+    endif
+
+
+    ! Stdlib is not 100% thread safe. print a warning to the user
+    if (package%meta%stdlib%on .and. package%meta%openmp%on) then
+        write(stdout,'(a)')'<WARNING> both openmp and stdlib requested: some functions may not be thread-safe!'
+    end if
+
+    ! MPI
+    if (package%meta%mpi%on) then
+        call add_metapackage_model(model,package,settings,"mpi",error)
+        if (allocated(error)) return
+    endif
+
+end subroutine resolve_metapackage_model
+
+!> Initialize MPI metapackage for the current system
+subroutine init_mpi(this,compiler,error)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+
+    type(string_t), allocatable :: c_wrappers(:),cpp_wrappers(:),fort_wrappers(:)
+    type(string_t) :: output,fwrap,cwrap,cxxwrap
+    character(256) :: msg_out
+    character(len=:), allocatable :: tokens(:)
+    integer :: wcfit(3),mpilib(3),ic,icpp,i
+    logical :: found
+
+    !> Cleanup
+    call destroy(this)
+
+    !> Get all candidate MPI wrappers
+    call mpi_wrappers(compiler,fort_wrappers,c_wrappers,cpp_wrappers)
+    if (verbose) print 1, size(fort_wrappers),size(c_wrappers),size(cpp_wrappers)
+
+    call wrapper_compiler_fit(fort_wrappers,c_wrappers,cpp_wrappers,compiler,wcfit,mpilib,error)
+
+    if (allocated(error) .or. all(wcfit==0)) then
+
+        !> No wrapper compiler fit. Are we on Windows? use MSMPI-specific search
+        found = msmpi_init(this,compiler,error)
+        if (allocated(error)) return
+
+        !> All attempts failed
+        if (.not.found) then
+            call fatal_error(error,"cannot find MPI wrappers or libraries for "//compiler%name()//" compiler")
+            return
+        endif
+
+    else
+
+        if (wcfit(LANG_FORTRAN)>0) fwrap   = fort_wrappers(wcfit(LANG_FORTRAN))
+        if (wcfit(LANG_C)>0)       cwrap   = c_wrappers   (wcfit(LANG_C))
+        if (wcfit(LANG_CXX)>0)     cxxwrap = cpp_wrappers (wcfit(LANG_CXX))
+
+        !> If there's only an available Fortran wrapper, and the compiler's different than fpm's baseline
+        !> fortran compiler suite, we still want to enable C language flags as that is most likely being
+        !> ABI-compatible anyways. However, issues may arise.
+        !> see e.g. Homebrew with clabng C/C++ and GNU fortran at https://gitlab.kitware.com/cmake/cmake/-/issues/18139
+        if (wcfit(LANG_FORTRAN)>0 .and. all(wcfit([LANG_C,LANG_CXX])==0)) then
+            cwrap   = fort_wrappers(wcfit(LANG_FORTRAN))
+            cxxwrap = fort_wrappers(wcfit(LANG_FORTRAN))
+        end if
+
+        if (verbose) print *, '+ MPI fortran wrapper: ',fwrap%s
+        if (verbose) print *, '+ MPI c       wrapper: ',cwrap%s
+        if (verbose) print *, '+ MPI c++     wrapper: ',cxxwrap%s
+
+        !> Initialize MPI package from wrapper command
+        call init_mpi_from_wrappers(this,compiler,mpilib(LANG_FORTRAN),fwrap,cwrap,cxxwrap,error)
+        if (allocated(error)) return
+
+        !> Request Fortran implicit typing
+        if (mpilib(LANG_FORTRAN)/=MPI_TYPE_INTEL) then
+            allocate(this%fortran)
+            this%fortran%implicit_typing   = .true.
+            this%fortran%implicit_external = .true.
+        endif
+
+    end if
+
+    !> Not all MPI implementations offer modules mpi and mpi_f08: hence, include them
+    !> to the list of external modules, so they won't be requested as standard source files
+    this%has_external_modules = .true.
+    this%external_modules = [string_t("mpi"),string_t("mpi_f08")]
+
+    1 format('MPI wrappers found: fortran=',i0,' c=',i0,' c++=',i0)
+
+end subroutine init_mpi
+
+!> Check if we're on a 64-bit environment
+!> Accept answer from https://stackoverflow.com/questions/49141093/get-system-information-with-fortran
+logical function is_64bit_environment()
+   use iso_c_binding, only: c_intptr_t
+   integer, parameter :: nbits = bit_size(0_c_intptr_t)
+   is_64bit_environment = nbits==64
+end function is_64bit_environment
+
+!> Check if there is a wrapper-compiler fit
+subroutine wrapper_compiler_fit(fort_wrappers,c_wrappers,cpp_wrappers,compiler,wrap,mpi,error)
+   type(string_t), allocatable, intent(in) :: fort_wrappers(:),c_wrappers(:),cpp_wrappers(:)
+   type(compiler_t), intent(in) :: compiler
+   type(error_t), allocatable, intent(out) :: error
+   integer, intent(out), dimension(3) :: wrap, mpi
+
+   type(error_t), allocatable :: wrap_error
+
+   wrap = 0
+   mpi  = MPI_TYPE_NONE
+
+   if (size(fort_wrappers)>0) &
+   call mpi_compiler_match(LANG_FORTRAN,fort_wrappers,compiler,wrap(LANG_FORTRAN),mpi(LANG_FORTRAN),wrap_error)
+
+   if (size(c_wrappers)>0) &
+   call mpi_compiler_match(LANG_C,c_wrappers,compiler,wrap(LANG_C),mpi(LANG_C),wrap_error)
+
+   if (size(cpp_wrappers)>0) &
+   call mpi_compiler_match(LANG_CXX,cpp_wrappers,compiler,wrap(LANG_CXX),mpi(LANG_CXX),wrap_error)
+
+   !> Find a Fortran wrapper for the current compiler
+   if (all(wrap==0)) then
+        call fatal_error(error,'no valid wrappers match current compiler, '//compiler_name(compiler))
+        return
+   end if
+
+end subroutine wrapper_compiler_fit
+
+!> Check if a local MS-MPI SDK build is found
+logical function msmpi_init(this,compiler,error) result(found)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    type(error_t), allocatable, intent(out) :: error
+
+    character(len=:), allocatable :: incdir,windir,libdir,bindir,post,reall,msysdir
+    type(version_t) :: ver,ver10
+    type(string_t) :: cpath,msys_path,runner_path
+    logical :: msys2
+
+    !> Default: not found
+    found = .false.
+
+    if (get_os_type()==OS_WINDOWS) then
+
+        ! to run MSMPI on Windows,
+        is_minGW: if (compiler%id==id_gcc) then
+
+            call compiler_get_version(compiler,ver,msys2,error)
+            if (allocated(error)) return
+
+        endif is_minGW
+
+        ! Check we're on a 64-bit environment
+        if (is_64bit_environment()) then
+            libdir = get_env('MSMPI_LIB64')
+            post   = 'x64'
+        else
+            libdir = get_env('MSMPI_LIB32')
+            post   = 'x86'
+
+            !> Not working on 32-bit Windows yet
+            call fatal_error(error,'MS-MPI error: this package requires 64-bit Windows environment')
+            return
+
+        end if
+
+        ! Check that the runtime is installed
+        bindir = ""
+        call get_absolute_path(get_env('MSMPI_BIN'),bindir,error)
+        if (verbose) print *, '+ %MSMPI_BIN%=',bindir
+
+        ! In some environments, variable %MSMPI_BIN% is missing (i.e. in GitHub Action images).
+        ! Do a second attempt: search for the default location
+        if (len_trim(bindir)<=0 .or. allocated(error)) then
+            if (verbose) print *, '+ %MSMPI_BIN% empty, searching C:\Program Files\Microsoft MPI\Bin\ ...'
+            call get_absolute_path('C:\Program Files\Microsoft MPI\Bin\mpiexec.exe',bindir,error)
+        endif
+
+        ! Do a third attempt: search for mpiexec.exe in PATH location
+        if (len_trim(bindir)<=0 .or. allocated(error)) then
+            if (verbose) print *, '+ C:\Program Files\Microsoft MPI\Bin\ not found. searching %PATH%...'
+
+            call get_mpi_runner(runner_path,verbose,error)
+
+            if (.not.allocated(error)) then
+               if (verbose) print *, '+ mpiexec found: ',runner_path%s
+               call find_command_location(runner_path%s,bindir,verbose=verbose,error=error)
+            endif
+
+        endif
+
+        if (allocated(error) .or. .not.exists(bindir)) then
+            call fatal_error(error,'MS-MPI error: MS-MPI Runtime directory is missing. '//&
+                                   'check environment variable %MSMPI_BIN% or that the folder is in %PATH%.')
+            return
+        end if
+
+        ! Success!
+        found = .true.
+
+        ! Init ms-mpi
+        call destroy(this)
+
+        ! MSYS2 provides a pre-built static msmpi.dll.a library. Use that if possible
+        use_prebuilt: if (msys2) then
+
+            ! MSYS executables are in %MSYS_ROOT%/bin
+            call compiler_get_path(compiler,cpath,error)
+            if (allocated(error)) return
+
+            call get_absolute_path(join_path(cpath%s,'..'),msys_path%s,error)
+            if (allocated(error)) return
+
+            call get_absolute_path(join_path(msys_path%s,'include'),incdir,error)
+            if (allocated(error)) return
+
+            call get_absolute_path(join_path(msys_path%s,'lib'),libdir,error)
+            if (allocated(error)) return
+
+            if (verbose) print 1, 'include',incdir,exists(incdir)
+            if (verbose) print 1, 'library',libdir,exists(libdir)
+
+            ! Check that the necessary files exist
+            call get_absolute_path(join_path(libdir,'libmsmpi.dll.a'),post,error)
+            if (allocated(error)) return
+
+            if (len_trim(post)<=0 .or. .not.exists(post)) then
+                call fatal_error(error,'MS-MPI available through the MSYS2 system not found. '// &
+                                       'Run <pacman -Sy mingw64/mingw-w64-x86_64-msmpi> '// &
+                                       'or your system-specific version to install.')
+                return
+            end if
+
+            ! Add dir cpath
+            this%has_link_flags = .true.
+            this%link_flags = string_t(' -L'//get_dos_path(libdir,error))
+
+            this%has_link_libraries = .true.
+            this%link_libs = [string_t('msmpi.dll')]
+
+            if (allocated(error)) return
+
+            this%has_include_dirs = .true.
+            this%incl_dirs = [string_t(get_dos_path(incdir,error))]
+            if (allocated(error)) return
+
+        else
+
+            call fatal_error(error,'MS-MPI cannot work with non-MSYS2 GNU compilers yet')
+            return
+
+            ! Add dir path
+            this%has_link_flags = .true.
+            this%link_flags = string_t(' -L'//get_dos_path(libdir,error))
+
+            this%has_link_libraries = .true.
+            this%link_libs = [string_t('msmpi'),string_t('msmpifec'),string_t('msmpifmc')]
+
+            if (allocated(error)) return
+
+            this%has_include_dirs = .true.
+            this%incl_dirs = [string_t(get_dos_path(incdir,error)), &
+                              string_t(get_dos_path(incdir//post,error))]
+            if (allocated(error)) return
+
+
+        end if use_prebuilt
+
+        !> Request Fortran implicit typing
+        allocate(this%fortran)
+        this%fortran%implicit_typing = .true.
+        this%fortran%implicit_external = .true.
+
+        ! gfortran>=10 is incompatible with the old-style mpif.h MS-MPI headers.
+        ! If so, add flags to allow old-style BOZ constants in mpif.h
+        allow_BOZ: if (compiler%id==id_gcc) then
+
+            call new_version(ver10,'10.0.0',error)
+            if (allocated(error)) return
+
+            if (ver>=ver10) then
+                this%has_build_flags = .true.
+                this%flags = string_t(' -fallow-invalid-boz')
+            end if
+
+        endif allow_BOZ
+
+        !> Add default run command
+        this%has_run_command = .true.
+        this%run_command = string_t(join_path(get_dos_path(bindir,error),'mpiexec.exe')//' -np * ')
+
+    else
+
+        !> Not on Windows
+        found = .false.
+
+    end if
+
+    1 format('MSMSPI ',a,' directory: PATH=',a,' EXISTS=',l1)
+
+end function msmpi_init
+
+!> Check if we're under a WSL bash shell
+logical function wsl_shell()
+    if (get_os_type()==OS_WINDOWS) then
+        wsl_shell = exists('/proc/sys/fs/binfmt_misc/WSLInterop')
+    else
+        wsl_shell = .false.
+    endif
+end function wsl_shell
+
+!> Find the location of a valid command
+subroutine find_command_location(command,path,echo,verbose,error)
+    character(*), intent(in) :: command
+    character(len=:), allocatable, intent(out) :: path
+    logical, optional, intent(in) :: echo,verbose
+    type(error_t), allocatable, intent(out) :: error
+
+    character(:), allocatable :: tmp_file,screen_output,line,fullpath,search_command
+    integer :: stat,iunit,ire,length,try
+    character(*), parameter :: search(2) = ["where ","which "]
+
+    if (len_trim(command)<=0) then
+        call fatal_error(error,'empty command provided in find_command_location')
+        return
+    end if
+
+    tmp_file = get_temp_filename()
+
+    ! On Windows, we try both commands because we may be on WSL
+    do try=merge(1,2,get_os_type()==OS_WINDOWS),2
+       search_command = search(try)//command
+       call run(search_command, echo=echo, exitstat=stat, verbose=verbose, redirect=tmp_file)
+       if (stat==0) exit
+    end do
+    if (stat/=0) then
+        call fatal_error(error,'find_command_location failed for '//command)
+        return
+    end if
+
+    ! Only read first instance (first line)
+    allocate(character(len=0) :: screen_output)
+    open(newunit=iunit,file=tmp_file,status='old',iostat=stat)
+    if (stat == 0)then
+       do
+           call getline(iunit, line, stat)
+           if (stat /= 0) exit
+           if (len(screen_output)>0) then
+                screen_output = screen_output//new_line('a')//line
+           else
+                screen_output = line
+           endif
+       end do
+       ! Close and delete file
+       close(iunit,status='delete')
+    else
+       call fatal_error(error,'cannot read temporary file from successful find_command_location')
+       return
+    endif
+
+    ! Only use the first instance
+    length = index(screen_output,new_line('a'))
+
+    multiline: if (length>1) then
+        fullpath = screen_output(1:length-1)
+    else
+        fullpath = screen_output
+    endif multiline
+    if (len_trim(fullpath)<1) then
+        call fatal_error(error,'no paths found to command ('//command//')')
+        return
+    end if
+
+    ! Extract path only
+    length = index(fullpath,command,BACK=.true.)
+    if (length<=0) then
+        call fatal_error(error,'full path to command ('//command//') does not include command name')
+        return
+    elseif (length==1) then
+        ! Compiler is in the current folder
+        path = '.'
+    else
+        path = fullpath(1:length-1)
+    end if
+    if (allocated(error)) return
+
+    ! On Windows, be sure to return a path with no spaces
+    if (get_os_type()==OS_WINDOWS) path = get_dos_path(path,error)
+
+    if (allocated(error) .or. .not.is_dir(path)) then
+        call fatal_error(error,'full path ('//path//') to command ('//command//') is not a directory')
+        return
+    end if
+
+end subroutine find_command_location
+
+!> Get MPI runner in $PATH
+subroutine get_mpi_runner(command,verbose,error)
+    type(string_t), intent(out) :: command
+    logical, intent(in) :: verbose
+    type(error_t), allocatable, intent(out) :: error
+
+    character(*), parameter :: try(*) = ['mpiexec    ','mpirun     ','mpiexec.exe','mpirun.exe ']
+    character(:), allocatable :: bindir
+    integer :: itri
+    logical :: success
+
+    ! Try several commands
+    do itri=1,size(try)
+       call find_command_location(trim(try(itri)),command%s,verbose=verbose,error=error)
+       if (allocated(error)) cycle
+
+       ! Success!
+       success = len_trim(command%s)>0
+       if (success) then
+           if (verbose) print *, '+ runner folder found: '//command%s
+           command%s = join_path(command%s,trim(try(itri)))
+           return
+       endif
+    end do
+
+    ! On windows, also search in %MSMPI_BIN%
+    if (get_os_type()==OS_WINDOWS) then
+        ! Check that the runtime is installed
+        bindir = ""
+        call get_absolute_path(get_env('MSMPI_BIN'),bindir,error)
+        if (verbose) print *, '+ %MSMPI_BIN%=',bindir
+        ! In some environments, variable %MSMPI_BIN% is missing (i.e. in GitHub Action images).
+        ! Do a second attempt: search for the default location
+        if (len_trim(bindir)<=0 .or. allocated(error)) then
+            if (verbose) print *, '+ %MSMPI_BIN% empty, searching C:\Program Files\Microsoft MPI\Bin\ ...'
+            call get_absolute_path('C:\Program Files\Microsoft MPI\Bin\mpiexec.exe',bindir,error)
+        endif
+        if (len_trim(bindir)>0 .and. .not.allocated(error)) then
+            ! MSMPI_BIN directory found
+            command%s = join_path(bindir,'mpiexec.exe')
+            return
+        endif
+    endif
+
+    ! No valid command found
+    call fatal_error(error,'cannot find a valid mpi runner command')
+    return
+
+end subroutine get_mpi_runner
+
+!> Return compiler path
+subroutine compiler_get_path(self,path,error)
+    type(compiler_t), intent(in) :: self
+    type(string_t), intent(out) :: path
+    type(error_t), allocatable, intent(out) :: error
+
+    call find_command_location(self%fc,path%s,self%echo,self%verbose,error)
+
+end subroutine compiler_get_path
+
+!> Return compiler version
+subroutine compiler_get_version(self,version,is_msys2,error)
+    type(compiler_t), intent(in) :: self
+    type(version_t), intent(out) :: version
+    logical, intent(out) :: is_msys2
+    type(error_t), allocatable, intent(out) :: error
+
+    character(:), allocatable :: tmp_file,screen_output,line
+    type(string_t) :: ver
+    integer :: stat,iunit,ire,length
+
+    is_msys2 = .false.
+
+    select case (self%id)
+       case (id_gcc)
+
+            tmp_file = get_temp_filename()
+
+            call run(self%fc // " --version ", echo=self%echo, verbose=self%verbose, redirect=tmp_file, exitstat=stat)
+            if (stat/=0) then
+                call fatal_error(error,'compiler_get_version failed for '//self%fc)
+                return
+            end if
+
+            allocate(character(len=0) :: screen_output)
+            open(newunit=iunit,file=tmp_file,status='old',iostat=stat)
+            if (stat == 0)then
+               do
+                   call getline(iunit, line, stat)
+                   if (stat /= 0) exit
+                   screen_output = screen_output//' '//line//' '
+               end do
+               ! Close and delete file
+               close(iunit,status='delete')
+            else
+               call fatal_error(error,'cannot read temporary file from successful compiler_get_version')
+               return
+            endif
+
+            ! Check if this gcc is from the MSYS2 project
+            is_msys2 = index(screen_output,'MSYS2')>0
+
+            ver = regex_version_from_text(screen_output,self%fc//' compiler',error)
+            if (allocated(error)) return
+
+            ! Extract version
+            call new_version(version,ver%s,error)
+
+
+       case default
+            call fatal_error(error,'compiler_get_version not yet implemented for compiler '//self%fc)
+            return
+    end select
+
+end subroutine compiler_get_version
+
+!> Initialize an MPI metapackage from a valid wrapper command ('mpif90', etc...)
+subroutine init_mpi_from_wrappers(this,compiler,mpilib,fort_wrapper,c_wrapper,cxx_wrapper,error)
+    class(metapackage_t), intent(inout) :: this
+    type(compiler_t), intent(in) :: compiler
+    integer, intent(in) :: mpilib
+    type(string_t), intent(in) :: fort_wrapper,c_wrapper,cxx_wrapper
+    type(error_t), allocatable, intent(out) :: error
+
+    type(version_t) :: version
+    type(error_t), allocatable :: runner_error
+
+    ! Cleanup structure
+    call destroy(this)
+
+    ! Get linking flags
+    if (mpilib/=MPI_TYPE_INTEL) then
+        this%link_flags = mpi_wrapper_query(mpilib,fort_wrapper,'link',verbose,error)
+
+        ! We fix OpenMPI's Fortran wrapper bug (https://github.com/open-mpi/ompi/issues/11636)
+        !call fix_openmpi_link_flags(this%link_flags,compiler,mpilib,fort_wrapper,c_wrapper,cxx_wrapper,error)
+
+        if (allocated(error)) return
+        this%has_link_flags = len_trim(this%link_flags)>0
+    endif
+
+    ! Request to use libs in arbitrary order
+    if (this%has_link_flags .and. compiler%is_gnu() .and. os_is_unix() .and. get_os_type()/=OS_MACOS) then
+        this%link_flags = string_t(' -Wl,--start-group '//this%link_flags%s)
+    end if
+
+
+    ! Add language-specific flags
+    call set_language_flags(mpilib,fort_wrapper,this%has_fortran_flags,this%fflags,verbose,error)
+    if (allocated(error)) return
+    call set_language_flags(mpilib,c_wrapper,this%has_c_flags,this%cflags,verbose,error)
+    if (allocated(error)) return
+    call set_language_flags(mpilib,cxx_wrapper,this%has_cxx_flags,this%cxxflags,verbose,error)
+    if (allocated(error)) return
+
+    ! Get library version
+    version = mpi_version_get(mpilib,fort_wrapper,error)
+    if (allocated(error)) then
+       return
+    else
+       allocate(this%version,source=version)
+    end if
+
+    !> Add default run command, if present
+    this%run_command = mpi_wrapper_query(mpilib,fort_wrapper,'runner',verbose,runner_error)
+    this%has_run_command = (len_trim(this%run_command)>0) .and. .not.allocated(runner_error)
+
+    contains
+
+    subroutine set_language_flags(mpilib,wrapper,has_flags,flags,verbose,error)
+        integer, intent(in) :: mpilib
+        type(string_t), intent(in) :: wrapper
+        logical, intent(inout) :: has_flags
+        type(string_t), intent(inout) :: flags
+        logical, intent(in) :: verbose
+        type(error_t), allocatable, intent(out) :: error
+
+        ! Get build flags for each language
+        if (len_trim(wrapper)>0) then
+            flags = mpi_wrapper_query(mpilib,wrapper,'flags',verbose,error)
+
+            if (allocated(error)) return
+            has_flags = len_trim(flags)>0
+
+            ! Add heading space
+            flags = string_t(' '//flags%s)
+
+            if (verbose) print *, '+ MPI language flags from wrapper <',wrapper%s,'>: flags=',flags%s
+
+        endif
+
+    end subroutine set_language_flags
+
+end subroutine init_mpi_from_wrappers
+
+!> Match one of the available compiler wrappers with the current compiler
+subroutine mpi_compiler_match(language,wrappers,compiler,which_one,mpilib,error)
+    integer, intent(in) :: language
+    type(string_t), intent(in) :: wrappers(:)
+    type(compiler_t), intent(in) :: compiler
+    integer, intent(out) :: which_one, mpilib
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: i
+    type(string_t) :: screen
+    character(128) :: msg_out
+    type(compiler_t) :: mpi_compiler
+
+    which_one = 0
+    mpilib = MPI_TYPE_NONE
+
+    do i=1,size(wrappers)
+
+        mpilib = which_mpi_library(wrappers(i),compiler,verbose=.false.)
+
+        screen = mpi_wrapper_query(mpilib,wrappers(i),'compiler',verbose=.false.,error=error)
+        if (allocated(error)) return
+
+        select case (language)
+           case (LANG_FORTRAN)
+               ! Build compiler type. The ID is created based on the Fortran name
+               call new_compiler(mpi_compiler,screen%s,'','',echo=.true.,verbose=.false.)
+
+               ! Fortran match found!
+               if (mpi_compiler%id == compiler%id) then
+                   which_one = i
+                   return
+               end if
+
+           case (LANG_C)
+               ! For other languages, we can only hope that the name matches the expected one
+               if (screen%s==compiler%cc .or. screen%s==compiler%fc) then
+                   which_one = i
+                   return
+               end if
+           case (LANG_CXX)
+               if (screen%s==compiler%cxx .or. screen%s==compiler%fc) then
+                   which_one = i
+                   return
+               end if
+        end select
+
+    end do
+
+    ! None of the available wrappers matched the current Fortran compiler
+    write(msg_out,1) size(wrappers),compiler%fc
+    call fatal_error(error,trim(msg_out))
+    1 format('<ERROR> None out of ',i0,' valid MPI wrappers matches compiler ',a)
+
+end subroutine mpi_compiler_match
+
+!> Return library version from the MPI wrapper command
+type(version_t) function mpi_version_get(mpilib,wrapper,error)
+   integer, intent(in) :: mpilib
+   type(string_t), intent(in) :: wrapper
+   type(error_t), allocatable, intent(out) :: error
+
+   type(string_t) :: version_line
+
+   ! Get version string
+   version_line = mpi_wrapper_query(mpilib,wrapper,'version',error=error)
+   if (allocated(error)) return
+
+   ! Wrap to object
+   call new_version(mpi_version_get,version_line%s,error)
+
+end function mpi_version_get
+
+!> Return several mpi wrappers, and return
+subroutine mpi_wrappers(compiler,fort_wrappers,c_wrappers,cpp_wrappers)
+    type(compiler_t), intent(in) :: compiler
+    type(string_t), allocatable, intent(out) :: c_wrappers(:),cpp_wrappers(:),fort_wrappers(:)
+
+    character(len=:), allocatable :: mpi_root,intel_wrap
+    type(error_t), allocatable :: error
+
+    ! Attempt gathering MPI wrapper names from the environment variables
+    c_wrappers    = [string_t(get_env('MPICC' ,'mpicc'))]
+    cpp_wrappers  = [string_t(get_env('MPICXX','mpic++'))]
+    fort_wrappers = [string_t(get_env('MPIFC' ,'mpifc' )),&
+                     string_t(get_env('MPIf90','mpif90')),&
+                     string_t(get_env('MPIf77','mpif77'))]
+
+    if (get_os_type()==OS_WINDOWS) then
+        c_wrappers = [c_wrappers,string_t('mpicc.bat')]
+        cpp_wrappers = [cpp_wrappers,string_t('mpicxx.bat')]
+        fort_wrappers = [fort_wrappers,string_t('mpifc.bat')]
+    endif
+
+    ! Add compiler-specific wrappers
+    compiler_specific: select case (compiler%id)
+       case (id_gcc,id_f95)
+
+            c_wrappers = [c_wrappers,string_t('mpigcc'),string_t('mpgcc')]
+          cpp_wrappers = [cpp_wrappers,string_t('mpig++'),string_t('mpg++')]
+         fort_wrappers = [fort_wrappers,string_t('mpigfortran'),string_t('mpgfortran'),&
+                          string_t('mpig77'),string_t('mpg77')]
+
+       case (id_intel_classic_windows,id_intel_llvm_windows, &
+             id_intel_classic_nix,id_intel_classic_mac,id_intel_llvm_nix,id_intel_llvm_unknown)
+
+            c_wrappers = [string_t(get_env('I_MPI_CC','mpiicc'))]
+          cpp_wrappers = [string_t(get_env('I_MPI_CXX','mpiicpc'))]
+         fort_wrappers = [string_t(get_env('I_MPI_F90','mpiifort'))]
+
+         ! Also search MPI wrappers via the base MPI folder
+         mpi_root = get_env('I_MPI_ROOT')
+         if (mpi_root/="") then
+
+             mpi_root = join_path(mpi_root,'bin')
+
+             intel_wrap = join_path(mpi_root,'mpiifort')
+             if (get_os_type()==OS_WINDOWS) intel_wrap = get_dos_path(intel_wrap,error)
+             if (intel_wrap/="") fort_wrappers = [fort_wrappers,string_t(intel_wrap)]
+
+             intel_wrap = join_path(mpi_root,'mpiicc')
+             if (get_os_type()==OS_WINDOWS) intel_wrap = get_dos_path(intel_wrap,error)
+             if (intel_wrap/="") c_wrappers = [c_wrappers,string_t(intel_wrap)]
+
+             intel_wrap = join_path(mpi_root,'mpiicpc')
+             if (get_os_type()==OS_WINDOWS) intel_wrap = get_dos_path(intel_wrap,error)
+             if (intel_wrap/="") cpp_wrappers = [cpp_wrappers,string_t(intel_wrap)]
+
+         end if
+
+       case (id_pgi,id_nvhpc)
+
+            c_wrappers = [c_wrappers,string_t('mpipgicc'),string_t('mpgcc')]
+          cpp_wrappers = [cpp_wrappers,string_t('mpipgic++')]
+         fort_wrappers = [fort_wrappers,string_t('mpipgifort'),string_t('mpipgf90')]
+
+       case (id_cray)
+
+            c_wrappers = [c_wrappers,string_t('cc')]
+          cpp_wrappers = [cpp_wrappers,string_t('CC')]
+         fort_wrappers = [fort_wrappers,string_t('ftn')]
+
+    end select compiler_specific
+
+    call assert_mpi_wrappers(fort_wrappers,compiler)
+    call assert_mpi_wrappers(c_wrappers,compiler)
+    call assert_mpi_wrappers(cpp_wrappers,compiler)
+
+end subroutine mpi_wrappers
+
+!> Filter out invalid/unavailable mpi wrappers
+subroutine assert_mpi_wrappers(wrappers,compiler,verbose)
+    type(string_t), allocatable, intent(inout) :: wrappers(:)
+    type(compiler_t), intent(in) :: compiler
+    logical, optional, intent(in) :: verbose
+
+    integer :: i
+    integer, allocatable :: works(:)
+
+    allocate(works(size(wrappers)))
+
+    do i=1,size(wrappers)
+        if (present(verbose)) then
+            if (verbose) print *, '+ MPI test wrapper <',wrappers(i)%s,'>'
+        endif
+        works(i) = which_mpi_library(wrappers(i),compiler,verbose)
+    end do
+
+    ! Filter out non-working wrappers
+    wrappers = pack(wrappers,works/=MPI_TYPE_NONE)
+
+end subroutine assert_mpi_wrappers
+
+!> Simple call to execute_command_line involving one mpi* wrapper
+subroutine run_mpi_wrapper(wrapper,args,verbose,exitcode,cmd_success,screen_output)
+    type(string_t), intent(in) :: wrapper
+    type(string_t), intent(in), optional :: args(:)
+    logical, intent(in), optional :: verbose
+    integer, intent(out), optional :: exitcode
+    logical, intent(out), optional :: cmd_success
+    type(string_t), intent(out), optional :: screen_output
+
+    logical :: echo_local
+    character(:), allocatable :: redirect_str,command,redirect,line
+    integer :: iunit,iarg,stat,cmdstat
+
+
+    if(present(verbose))then
+       echo_local=verbose
+    else
+       echo_local=.false.
+    end if
+
+    ! No redirection and non-verbose output
+    if (present(screen_output)) then
+        redirect = get_temp_filename()
+        redirect_str =  ">"//redirect//" 2>&1"
+    else
+        if (os_is_unix()) then
+            redirect_str = " >/dev/null 2>&1"
+        else
+            redirect_str = " >NUL 2>&1"
+        end if
+    end if
+
+    ! Empty command
+    if (len_trim(wrapper)<=0) then
+        if (echo_local) print *, '+ <EMPTY COMMAND>'
+        if (present(exitcode)) exitcode = 0
+        if (present(cmd_success)) cmd_success = .true.
+        if (present(screen_output)) screen_output = string_t("")
+        return
+    end if
+
+    ! Init command
+    command = trim(wrapper%s)
+
+    add_arguments: if (present(args)) then
+        do iarg=1,size(args)
+            if (len_trim(args(iarg))<=0) cycle
+            command = trim(command)//' '//args(iarg)%s
+        end do
+    endif add_arguments
+
+    if (echo_local) print *, '+ ', command
+
+    ! Test command
+    call execute_command_line(command//redirect_str,exitstat=stat,cmdstat=cmdstat)
+
+    ! Command successful?
+    if (present(cmd_success)) cmd_success = cmdstat==0
+
+    ! Program exit code?
+    if (present(exitcode)) exitcode = stat
+
+    ! Want screen output?
+    if (present(screen_output) .and. cmdstat==0) then
+
+        allocate(character(len=0) :: screen_output%s)
+
+        open(newunit=iunit,file=redirect,status='old',iostat=stat)
+        if (stat == 0)then
+           do
+               call getline(iunit, line, stat)
+               if (stat /= 0) exit
+
+               screen_output%s = screen_output%s//new_line('a')//line
+
+               if (echo_local) write(*,'(A)') trim(line)
+           end do
+
+           ! Close and delete file
+           close(iunit,status='delete')
+
+        else
+           call fpm_stop(1,'cannot read temporary file from successful MPI wrapper')
+        endif
+
+    end if
+
+end subroutine run_mpi_wrapper
+
+!> Get MPI library type from the wrapper command. Currently, only OpenMPI is supported
+integer function which_mpi_library(wrapper,compiler,verbose)
+    type(string_t), intent(in) :: wrapper
+    type(compiler_t), intent(in) :: compiler
+    logical, intent(in), optional :: verbose
+
+    logical :: is_mpi_wrapper
+    integer :: stat
+
+    ! Init as currently unsupported library
+    which_mpi_library = MPI_TYPE_NONE
+
+    if (len_trim(wrapper)<=0) return
+
+    ! Run mpi wrapper first
+    call run_mpi_wrapper(wrapper,verbose=verbose,cmd_success=is_mpi_wrapper)
+
+    if (is_mpi_wrapper) then
+
+        if (compiler%is_intel()) then
+            which_mpi_library = MPI_TYPE_INTEL
+            return
+        end if
+
+        ! Attempt to decipher which library this wrapper comes from.
+
+        ! OpenMPI responds to '--showme' calls
+        call run_mpi_wrapper(wrapper,[string_t('--showme')],verbose,&
+                             exitcode=stat,cmd_success=is_mpi_wrapper)
+        if (stat==0 .and. is_mpi_wrapper) then
+            which_mpi_library = MPI_TYPE_OPENMPI
+            return
+        endif
+
+        ! MPICH responds to '-show' calls
+        call run_mpi_wrapper(wrapper,[string_t('-show')],verbose,&
+                             exitcode=stat,cmd_success=is_mpi_wrapper)
+        if (stat==0 .and. is_mpi_wrapper) then
+            which_mpi_library = MPI_TYPE_MPICH
+            return
+        endif
+
+    end if
+
+end function which_mpi_library
+
+!> Test if an MPI wrapper works
+type(string_t) function mpi_wrapper_query(mpilib,wrapper,command,verbose,error) result(screen)
+    integer, intent(in) :: mpilib
+    type(string_t), intent(in) :: wrapper
+    character(*), intent(in) :: command
+    logical, intent(in), optional :: verbose
+    type(error_t), allocatable, intent(out) :: error
+
+    logical :: success
+    character(:), allocatable :: redirect_str,tokens(:),unsupported_msg
+    type(string_t) :: cmdstr
+    type(compiler_t) :: mpi_compiler
+    integer :: stat,cmdstat,ire,length
+
+    unsupported_msg = 'the MPI library of wrapper '//wrapper%s//' does not support task '//trim(command)
+
+    select case (command)
+
+       ! Get MPI compiler name
+       case ('compiler')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI); cmdstr = string_t('--showme:command')
+              case (MPI_TYPE_MPICH);   cmdstr = string_t('-compile-info')
+              case (MPI_TYPE_INTEL);   cmdstr = string_t('-show')
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+           call run_mpi_wrapper(wrapper,[cmdstr],verbose=verbose, &
+                                exitcode=stat,cmd_success=success,screen_output=screen)
+
+           if (stat/=0 .or. .not.success) then
+              call syntax_error(error,'local '//MPI_TYPE_NAME(mpilib)//&
+                                      ' library wrapper does not support flag '//cmdstr%s)
+              return
+           end if
+
+           ! Take out the first command from the whole line
+           call split(screen%s,tokens,delimiters=' ')
+           screen%s = trim(adjustl(tokens(1)))
+
+       ! Get a list of additional compiler flags
+       case ('flags')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI); cmdstr = string_t('--showme:compile')
+              case (MPI_TYPE_MPICH);   cmdstr = string_t('-compile-info')
+              case (MPI_TYPE_INTEL);   cmdstr = string_t('-show')
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+           call run_mpi_wrapper(wrapper,[cmdstr],verbose=verbose, &
+                                exitcode=stat,cmd_success=success,screen_output=screen)
+
+           if (stat/=0 .or. .not.success) then
+              call syntax_error(error,'local '//MPI_TYPE_NAME(mpilib)//&
+                                      ' library wrapper does not support flag '//cmdstr%s)
+              return
+           end if
+
+           ! Post-process output
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI)
+                 ! This library reports the compiler name only
+                 call remove_newline_characters(screen)
+              case (MPI_TYPE_MPICH,MPI_TYPE_INTEL)
+                 ! These libraries report the full command including the compiler name. Remove it if so
+                 call remove_newline_characters(screen)
+                 call split(screen%s,tokens)
+                 ! Remove trailing compiler name
+                 screen%s = screen%s(len_trim(tokens(1))+1:)
+              case default
+                 call fatal_error(error,'invalid MPI library type')
+                 return
+           end select
+
+       ! Get a list of additional linker flags
+       case ('link')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI); cmdstr = string_t('--showme:link')
+              case (MPI_TYPE_MPICH);   cmdstr = string_t('-link-info')
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+           call run_mpi_wrapper(wrapper,[cmdstr],verbose=verbose, &
+                                exitcode=stat,cmd_success=success,screen_output=screen)
+
+           if (stat/=0 .or. .not.success) then
+              call syntax_error(error,'local '//MPI_TYPE_NAME(mpilib)//&
+                                      ' library wrapper does not support flag '//cmdstr%s)
+              return
+           end if
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI)
+                 call remove_newline_characters(screen)
+              case (MPI_TYPE_MPICH)
+                 ! MPICH reports the full command including the compiler name. Remove it if so
+                 call remove_newline_characters(screen)
+                 call split(screen%s,tokens)
+                 ! Remove trailing compiler name
+                 screen%s = screen%s(len_trim(tokens(1))+1:)
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+       ! Get a list of MPI library directories
+       case ('link_dirs')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI)
+
+                 ! --showme:command returns the build command of this wrapper
+                 call run_mpi_wrapper(wrapper,[string_t('--showme:libdirs')],verbose=verbose, &
+                                      exitcode=stat,cmd_success=success,screen_output=screen)
+
+                 if (stat/=0 .or. .not.success) then
+                    call syntax_error(error,'local OpenMPI library does not support --showme:libdirs')
+                    return
+                 end if
+
+              case default
+
+                 call fatal_error(error,unsupported_msg)
+                 return
+
+           end select
+
+       ! Get a list of include directories for the MPI headers/modules
+       case ('incl_dirs')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI)
+                 ! --showme:command returns the build command of this wrapper
+                 call run_mpi_wrapper(wrapper,[string_t('--showme:incdirs')],verbose=verbose, &
+                                      exitcode=stat,cmd_success=success,screen_output=screen)
+                 if (stat/=0 .or. .not.success) then
+                    call syntax_error(error,'local OpenMPI library does not support --showme:incdirs')
+                    return
+                 end if
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+           call remove_newline_characters(screen)
+
+       ! Retrieve library version
+       case ('version')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI)
+
+                 ! --showme:command returns the build command of this wrapper
+                 call run_mpi_wrapper(wrapper,[string_t('--showme:version')],verbose=verbose, &
+                                      exitcode=stat,cmd_success=success,screen_output=screen)
+
+                 if (stat/=0 .or. .not.success) then
+                    call syntax_error(error,'local OpenMPI library does not support --showme:version')
+                    return
+                 else
+                    call remove_newline_characters(screen)
+                 end if
+
+              case (MPI_TYPE_MPICH)
+
+                 !> MPICH offers command "mpichversion" in the same system folder as the MPI wrappers.
+                 !> So, attempt to run that first
+                 cmdstr = string_t('mpichversion')
+                 call run_mpi_wrapper(cmdstr,verbose=verbose, &
+                                      exitcode=stat,cmd_success=success,screen_output=screen)
+
+                 ! Second option: run mpich wrapper + "-v"
+                 if (stat/=0 .or. .not.success) then
+                    call run_mpi_wrapper(wrapper,[string_t('-v')],verbose=verbose, &
+                                         exitcode=stat,cmd_success=success,screen_output=screen)
+                    call remove_newline_characters(screen)
+                 endif
+
+                 ! Third option: mpiexec --version
+                 if (stat/=0 .or. .not.success) then
+                     cmdstr = string_t('mpiexec --version')
+                     call run_mpi_wrapper(cmdstr,verbose=verbose, &
+                                          exitcode=stat,cmd_success=success,screen_output=screen)
+                 endif
+
+                 if (stat/=0 .or. .not.success) then
+                    call syntax_error(error,'cannot retrieve MPICH library version from <mpichversion, '//wrapper%s//', mpiexec>')
+                    return
+                 end if
+
+              case (MPI_TYPE_INTEL)
+
+                 ! --showme:command returns the build command of this wrapper
+                 call run_mpi_wrapper(wrapper,[string_t('-v')],verbose=verbose, &
+                                      exitcode=stat,cmd_success=success,screen_output=screen)
+
+                 if (stat/=0 .or. .not.success) then
+                    call syntax_error(error,'local INTEL MPI library does not support -v')
+                    return
+                 else
+                    call remove_newline_characters(screen)
+                 end if
+
+              case default
+
+                 call fatal_error(error,unsupported_msg)
+                 return
+
+           end select
+
+           ! Extract version
+           screen = regex_version_from_text(screen%s,MPI_TYPE_NAME(mpilib)//' library',error)
+           if (allocated(error)) return
+
+       ! Get path to the MPI runner command
+       case ('runner')
+
+           select case (mpilib)
+              case (MPI_TYPE_OPENMPI,MPI_TYPE_MPICH,MPI_TYPE_MSMPI,MPI_TYPE_INTEL)
+                 call get_mpi_runner(screen,verbose,error)
+              case default
+                 call fatal_error(error,unsupported_msg)
+                 return
+           end select
+
+       case default;
+           call fatal_error(error,'an invalid MPI wrapper command ('//command//&
+                                  ') was invoked for wrapper <'//wrapper%s//'>.')
+           return
+    end select
+
+
+end function mpi_wrapper_query
+
+end module fpm_meta
diff --git a/src/fpm_os.F90 b/src/fpm_os.F90
index f0e2f5437e..9de85e7584 100644
--- a/src/fpm_os.F90
+++ b/src/fpm_os.F90
@@ -246,7 +246,7 @@ subroutine get_absolute_path_by_cd(path, absolute_path, error)
 
     !> Converts a path to an absolute, canonical path.
     subroutine convert_to_absolute_path(path, error)
-        character(len=*), intent(inout) :: path
+        character(len=:), allocatable, intent(inout) :: path
         type(error_t), allocatable, intent(out) :: error
 
         character(len=:), allocatable :: absolute_path
diff --git a/src/fpm_os.c b/src/fpm_os.c
index 2d417a0695..49e1a4d5f4 100644
--- a/src/fpm_os.c
+++ b/src/fpm_os.c
@@ -5,7 +5,7 @@
 /// @param resolved_path
 /// @param maxLength
 /// @return
-int c_realpath(char* path, char* resolved_path, int maxLength) {
+char* c_realpath(char* path, char* resolved_path, int maxLength) {
 // Checking macro in C because it doesn't work with gfortran on Windows, even
 // when exported manually.
 #ifndef _WIN32
diff --git a/src/fpm_settings.f90 b/src/fpm_settings.f90
index 75fbb21d2b..fe4b0748fa 100644
--- a/src/fpm_settings.f90
+++ b/src/fpm_settings.f90
@@ -4,13 +4,14 @@ module fpm_settings
   use fpm_environment, only: os_is_unix
   use fpm_error, only: error_t, fatal_error
   use fpm_toml, only: toml_table, toml_error, toml_stat, get_value, toml_load, check_keys
-  use fpm_os, only: get_current_directory, change_directory, get_absolute_path, &
-                    convert_to_absolute_path
+  use fpm_os, only: get_current_directory, change_directory, get_absolute_path, convert_to_absolute_path
+
   implicit none
   private
   public :: fpm_global_settings, get_global_settings, get_registry_settings, official_registry_base_url
 
   character(*), parameter :: official_registry_base_url = 'https://registry-apis.vercel.app'
+  character(*), parameter :: default_config_file_name = 'config.toml'
 
   type :: fpm_global_settings
     !> Path to the global config file excluding the file name.
@@ -20,7 +21,7 @@ module fpm_settings
     !> Registry configs.
     type(fpm_registry_settings), allocatable :: registry_settings
   contains
-    procedure :: has_custom_location, full_path
+    procedure :: has_custom_location, full_path, path_to_config_folder_or_empty
   end type
 
   type :: fpm_registry_settings
@@ -77,7 +78,7 @@ subroutine get_global_settings(global_settings, error)
       end if
 
       ! Use default file name.
-      global_settings%config_file_name = 'config.toml'
+      global_settings%config_file_name = default_config_file_name
 
       ! Apply default registry settings and return if config file doesn't exist.
       if (.not. exists(global_settings%full_path())) then
@@ -105,8 +106,7 @@ subroutine get_global_settings(global_settings, error)
     else
       call use_default_registry_settings(global_settings)
     end if
-
-  end subroutine get_global_settings
+  end
 
   !> Default registry settings are typically applied if the config file doesn't exist or no registry table was found in
   !> the global config file.
@@ -115,9 +115,9 @@ subroutine use_default_registry_settings(global_settings)
 
     allocate (global_settings%registry_settings)
     global_settings%registry_settings%url = official_registry_base_url
-    global_settings%registry_settings%cache_path = join_path(global_settings%path_to_config_folder, &
+    global_settings%registry_settings%cache_path = join_path(global_settings%path_to_config_folder_or_empty(), &
     & 'dependencies')
-  end subroutine use_default_registry_settings
+  end
 
   !> Read registry settings from the global config file.
   subroutine get_registry_settings(table, global_settings, error)
@@ -155,7 +155,7 @@ subroutine get_registry_settings(table, global_settings, error)
         global_settings%registry_settings%path = path
       else
         ! Get canonical, absolute path on both Unix and Windows.
-        call get_absolute_path(join_path(global_settings%path_to_config_folder, path), &
+        call get_absolute_path(join_path(global_settings%path_to_config_folder_or_empty(), path), &
         & global_settings%registry_settings%path, error)
         if (allocated(error)) return
 
@@ -201,31 +201,44 @@ subroutine get_registry_settings(table, global_settings, error)
         if (.not. exists(cache_path)) call mkdir(cache_path)
         global_settings%registry_settings%cache_path = cache_path
       else
-        cache_path = join_path(global_settings%path_to_config_folder, cache_path)
+        cache_path = join_path(global_settings%path_to_config_folder_or_empty(), cache_path)
         if (.not. exists(cache_path)) call mkdir(cache_path)
         ! Get canonical, absolute path on both Unix and Windows.
         call get_absolute_path(cache_path, global_settings%registry_settings%cache_path, error)
         if (allocated(error)) return
       end if
     else if (.not. allocated(path)) then
-      global_settings%registry_settings%cache_path = join_path(global_settings%path_to_config_folder, &
-      & 'dependencies')
+      global_settings%registry_settings%cache_path = &
+        join_path(global_settings%path_to_config_folder_or_empty(), 'dependencies')
     end if
-  end subroutine get_registry_settings
+  end
 
   !> True if the global config file is not at the default location.
-  pure logical function has_custom_location(self)
+  elemental logical function has_custom_location(self)
     class(fpm_global_settings), intent(in) :: self
 
     has_custom_location = allocated(self%path_to_config_folder) .and. allocated(self%config_file_name)
-  end function
+    if (.not. has_custom_location) return
+    has_custom_location = len_trim(self%path_to_config_folder) > 0 .and. len_trim(self%config_file_name) > 0
+  end
 
   !> The full path to the global config file.
   function full_path(self) result(result)
     class(fpm_global_settings), intent(in) :: self
     character(len=:), allocatable :: result
 
-    result = join_path(self%path_to_config_folder, self%config_file_name)
-  end function
+    result = join_path(self%path_to_config_folder_or_empty(), self%config_file_name)
+  end
+
+  !> The path to the global config directory.
+  pure function path_to_config_folder_or_empty(self)
+    class(fpm_global_settings), intent(in) :: self
+    character(len=:), allocatable :: path_to_config_folder_or_empty
 
-end module fpm_settings
+    if (allocated(self%path_to_config_folder)) then
+      path_to_config_folder_or_empty = self%path_to_config_folder
+    else
+      path_to_config_folder_or_empty = ""
+    end if
+  end
+end
diff --git a/src/fpm_source_parsing.f90 b/src/fpm_source_parsing.f90
index 6d22ef4a6c..f303a1c2cf 100644
--- a/src/fpm_source_parsing.f90
+++ b/src/fpm_source_parsing.f90
@@ -27,15 +27,7 @@ module fpm_source_parsing
 implicit none
 
 private
-public :: parse_f_source, parse_c_source
-
-character(15), parameter :: INTRINSIC_MODULE_NAMES(*) =  &
-                             ['iso_c_binding  ', &
-                              'iso_fortran_env', &
-                              'ieee_arithmetic', &
-                              'ieee_exceptions', &
-                              'ieee_features  ', &
-                              'omp_lib        ']
+public :: parse_f_source, parse_c_source, parse_use_statement
 
 contains
 
@@ -77,7 +69,7 @@ function parse_f_source(f_filename,error) result(f_source)
     type(srcfile_t) :: f_source
     type(error_t), allocatable, intent(out) :: error
 
-    logical :: inside_module, inside_interface
+    logical :: inside_module, inside_interface, using, intrinsic_module
     integer :: stat
     integer :: fh, n_use, n_include, n_mod, n_parent, i, j, ic, pass
     type(string_t), allocatable :: file_lines(:), file_lines_lower(:)
@@ -123,7 +115,7 @@ function parse_f_source(f_filename,error) result(f_source)
             ! Detect exported C-API via bind(C)
             if (.not.inside_interface .and. &
                 parse_subsequence(file_lines_lower(i)%s,'bind','(','c')) then
-                
+
                 do j=i,1,-1
 
                     if (index(file_lines_lower(j)%s,'function') > 0 .or. &
@@ -179,59 +171,24 @@ function parse_f_source(f_filename,error) result(f_source)
             end if
 
             ! Process 'USE' statements
-            if (index(file_lines_lower(i)%s,'use ') == 1 .or. &
-                index(file_lines_lower(i)%s,'use::') == 1) then
-
-                if (index(file_lines_lower(i)%s,'::') > 0) then
+            call parse_use_statement(f_filename,i,file_lines_lower(i)%s,using,intrinsic_module,mod_name,error)
+            if (allocated(error)) return
 
-                    temp_string = split_n(file_lines_lower(i)%s,delims=':',n=2,stat=stat)
-                    if (stat /= 0) then
-                        call file_parse_error(error,f_filename, &
-                                'unable to find used module name',i, &
-                                file_lines_lower(i)%s,index(file_lines_lower(i)%s,'::'))
-                        return
-                    end if
-
-                    mod_name = split_n(temp_string,delims=' ,',n=1,stat=stat)
-                    if (stat /= 0) then
-                        call file_parse_error(error,f_filename, &
-                                 'unable to find used module name',i, &
-                                 file_lines_lower(i)%s)
-                        return
-                    end if
+            if (using) then
 
-                else
+                ! Not a valid module name?
+                if (.not.is_fortran_name(mod_name)) cycle
 
-                    mod_name = split_n(file_lines_lower(i)%s,n=2,delims=' ,',stat=stat)
-                    if (stat /= 0) then
-                        call file_parse_error(error,f_filename, &
-                                'unable to find used module name',i, &
-                                file_lines_lower(i)%s)
-                        return
-                    end if
-
-                end if
-
-                if (.not.is_fortran_name(mod_name)) then
-                    cycle
-                end if
-
-                if (any([(index(mod_name,trim(INTRINSIC_MODULE_NAMES(j)))>0, &
-                            j=1,size(INTRINSIC_MODULE_NAMES))])) then
-                    cycle
-                end if
+                ! Valid intrinsic module: not a dependency
+                if (intrinsic_module) cycle
 
                 n_use = n_use + 1
 
-                if (pass == 2) then
-
-                    f_source%modules_used(n_use)%s = mod_name
-
-                end if
+                if (pass == 2) f_source%modules_used(n_use)%s = mod_name
 
                 cycle
 
-            end if
+            endif
 
             ! Process 'INCLUDE' statements
             ic = index(file_lines_lower(i)%s,'include')
@@ -302,7 +259,7 @@ function parse_f_source(f_filename,error) result(f_source)
                     f_source%unit_type = FPM_UNIT_MODULE
                 end if
 
-                if (.not.inside_module) then    
+                if (.not.inside_module) then
                     inside_module = .true.
                 else
                     ! Must have missed an end module statement (can't assume a pure module)
@@ -341,7 +298,7 @@ function parse_f_source(f_filename,error) result(f_source)
                           file_lines_lower(i)%s)
                     return
                 end if
-                
+
                 if (f_source%unit_type /= FPM_UNIT_PROGRAM) then
                     f_source%unit_type = FPM_UNIT_SUBMODULE
                 end if
@@ -403,7 +360,7 @@ function parse_f_source(f_filename,error) result(f_source)
             !  (to check for code outside of modules)
             if (parse_sequence(file_lines_lower(i)%s,'end','module') .or. &
                 parse_sequence(file_lines_lower(i)%s,'end','submodule')) then
-                
+
                 inside_module = .false.
                 cycle
 
@@ -460,7 +417,7 @@ function parse_c_source(c_filename,error) result(c_source)
 
         c_source%unit_type = FPM_UNIT_CHEADER
 
-    else if (str_ends_with(lower(c_filename), ".cpp")) then 
+    else if (str_ends_with(lower(c_filename), ".cpp")) then
 
         c_source%unit_type = FPM_UNIT_CPPSOURCE
 
@@ -542,6 +499,7 @@ function split_n(string,delims,n,stat) result(substring)
     if (n<1) then
         i = size(string_parts) + n
         if (i < 1) then
+            allocate(character(len=0) :: substring) ! ifort bus error otherwise
             stat = 1
             return
         end if
@@ -550,6 +508,7 @@ function split_n(string,delims,n,stat) result(substring)
     end if
 
     if (i>size(string_parts)) then
+        allocate(character(len=0) :: substring) ! ifort bus error otherwise
         stat = 1
         return
     end if
@@ -573,7 +532,7 @@ function parse_subsequence(string,t1,t2,t3,t4) result(found)
     found = .false.
     offset = 1
 
-    do 
+    do
 
         i = index(string(offset:),t1)
 
@@ -653,5 +612,117 @@ function parse_sequence(string,t1,t2,t3,t4) result(found)
 
 end function parse_sequence
 
+! USE [, intrinsic] :: module_name [, only: only_list]
+! USE [, non_intrinsic] :: module_name [, only: only_list]
+subroutine parse_use_statement(f_filename,i,line,use_stmt,is_intrinsic,module_name,error)
+
+    !> Current file name and line number (for error messaging)
+    character(*), intent(in) :: f_filename
+    integer, intent(in) :: i
+
+    !> The line being parsed. MUST BE preprocessed with trim(adjustl()
+    character(*), intent(in) :: line
+
+    !> Does this line contain a `use` statement?
+    logical, intent(out) :: use_stmt
+
+    !> Is the module in this statement intrinsic?
+    logical, intent(out) :: is_intrinsic
+
+    !> used module name
+    character(:), allocatable, intent(out) :: module_name
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    character(15), parameter :: INTRINSIC_NAMES(*) =  &
+                                 ['iso_c_binding  ', &
+                                  'iso_fortran_env', &
+                                  'ieee_arithmetic', &
+                                  'ieee_exceptions', &
+                                  'ieee_features  ', &
+                                  'omp_lib        ']
+
+    character(len=:), allocatable :: temp_string
+    integer :: colons,intr,nonintr,j,stat
+    logical :: has_intrinsic_name
+
+    use_stmt      = .false.
+    is_intrinsic  = .false.
+    if (len_trim(line)<=0) return
+
+    ! Quick check that the line is preprocessed
+    if (line(1:1)==' ') then
+        call fatal_error(error,'internal_error: source file line is not trim(adjustl()) on input to parse_use_statement')
+        return
+    end if
+
+    ! 'use' should be the first string in the adjustl line
+    use_stmt = index(line,'use ')==1 .or. index(line,'use::')==1 .or. index(line,'use,')==1
+    if (.not.use_stmt) return
+    colons   = index(line,'::')
+    nonintr  = 0
+    intr     = 0
+
+    have_colons: if (colons>3) then
+
+        ! there may be an intrinsic/non-intrinsic spec
+        nonintr = index(line(1:colons-1),'non_intrinsic')
+        if (nonintr==0) intr = index(line(1:colons-1),'intrinsic')
+
+
+        temp_string = split_n(line,delims=':',n=2,stat=stat)
+        if (stat /= 0) then
+            call file_parse_error(error,f_filename, &
+                    'unable to find used module name',i, &
+                    line,colons)
+            return
+        end if
+
+        module_name = split_n(temp_string,delims=' ,',n=1,stat=stat)
+        if (stat /= 0) then
+            call file_parse_error(error,f_filename, &
+                     'unable to find used module name',i, &
+                     line)
+            return
+        end if
+
+    else
+
+        module_name = split_n(line,n=2,delims=' ,',stat=stat)
+        if (stat /= 0) then
+            call file_parse_error(error,f_filename, &
+                    'unable to find used module name',i, &
+                    line)
+            return
+        end if
+
+    end if have_colons
+
+    ! If declared intrinsic, check that it is true
+    has_intrinsic_name = any([(index(module_name,trim(INTRINSIC_NAMES(j)))>0, &
+                             j=1,size(INTRINSIC_NAMES))])
+    if (intr>0 .and. .not.has_intrinsic_name) then
+
+        ! An intrinsic module was not found. Its name could be in the next line,
+        ! in which case, we just skip this check. The compiler will do the job if the name is invalid.
+
+        ! Module name was not read: it's in the next line
+        if (index(module_name,'&')<=0) then
+            call file_parse_error(error,f_filename, &
+                                  'module '//module_name//' is declared intrinsic but it is not ',i, &
+                                  line)
+            return
+        endif
+    endif
+
+    ! Should we treat this as an intrinsic module
+    is_intrinsic = nonintr==0 .and. & ! not declared non-intrinsic
+                   (intr>0 .or. has_intrinsic_name)
+
+end subroutine parse_use_statement
+
+
+
 end module fpm_source_parsing
 
diff --git a/src/fpm_sources.f90 b/src/fpm_sources.f90
index 68251e59e5..0165249f50 100644
--- a/src/fpm_sources.f90
+++ b/src/fpm_sources.f90
@@ -7,6 +7,7 @@ module fpm_sources
 use fpm_error, only: error_t
 use fpm_model, only: srcfile_t, FPM_UNIT_PROGRAM
 use fpm_filesystem, only: basename, canon_path, dirname, join_path, list_files, is_hidden_file
+use fpm_environment, only: get_os_type,OS_WINDOWS
 use fpm_strings, only: lower, str_ends_with, string_t, operator(.in.)
 use fpm_source_parsing, only: parse_f_source, parse_c_source
 use fpm_manifest_executable, only: executable_config_t
@@ -14,6 +15,7 @@ module fpm_sources
 
 private
 public :: add_sources_from_dir, add_executable_sources
+public :: get_exe_name_with_suffix
 
 character(4), parameter :: fortran_suffixes(2) = [".f90", &
                                                   ".f  "]
@@ -232,4 +234,21 @@ subroutine get_executable_source_dirs(exe_dirs,executables)
 
 end subroutine get_executable_source_dirs
 
+!> Build an executable name with suffix. Safe routine that always returns an allocated string
+function get_exe_name_with_suffix(source) result(suffixed)
+    type(srcfile_t), intent(in) :: source
+    character(len=:), allocatable :: suffixed
+
+    if (allocated(source%exe_name)) then
+       if (get_os_type() == OS_WINDOWS) then
+           suffixed = source%exe_name//'.exe'
+       else
+           suffixed = source%exe_name
+       end if
+    else
+       suffixed = ""
+    endif
+
+end function get_exe_name_with_suffix
+
 end module fpm_sources
diff --git a/src/fpm_strings.f90 b/src/fpm_strings.f90
index 20b004b1c0..759fec8f54 100644
--- a/src/fpm_strings.f90
+++ b/src/fpm_strings.f90
@@ -23,7 +23,8 @@
 !! - [[IS_FORTRAN_NAME]]  determine whether a string is an acceptable Fortran entity name
 !! - [[TO_FORTRAN_NAME]]  replace allowed special but unusuable characters in names with underscore
 !!### Whitespace
-!! - [[NOTABS]]  Expand tab characters assuming a tab space every eight characters
+!! - [[NOTABS]]  subroutine to expand tab characters assuming a tab space every eight characters
+!! - [[DILATE]]  function to expand tab characters assuming a tab space every eight characters
 !! - [[LEN_TRIM]]  Determine total trimmed length of **STRING_T** array
 !!### Miscellaneous
 !! - [[FNV_1A]]  Hash a **CHARACTER(*)** string of default kind or a **TYPE(STRING_T)** array
@@ -43,7 +44,7 @@ module fpm_strings
 public :: to_fortran_name, is_fortran_name
 public :: string_array_contains, string_cat, len_trim, operator(.in.), fnv_1a
 public :: replace, resize, str, join, glob
-public :: notabs
+public :: notabs, dilate, remove_newline_characters, remove_characters_in_set
 public :: operator(==)
 
 !> Module naming
@@ -242,9 +243,9 @@ pure function fnv_1a_string_t(input, seed) result(hash)
 end function fnv_1a_string_t
 
 
- !>Author: John S. Urban
- !!License: Public Domain
- !! Changes a string to lowercase over optional specified column range
+!>Author: John S. Urban
+!!License: Public Domain
+!! Changes a string to lowercase over optional specified column range
 elemental pure function lower(str,begin,end) result (string)
 
     character(*), intent(In)     :: str
@@ -661,8 +662,9 @@ pure function join(str,sep,trm,left,right,start,end) result (string)
    if(present(end))string=string//end
 end function join
 
-!>##AUTHOR John S. Urban
-!!##LICENSE Public Domain
+!>AUTHOR: John S. Urban
+!!LICENSE: Public Domain
+!>
 !!## NAME
 !!    glob(3f) - [fpm_strings:COMPARE] compare given string for match to
 !!    pattern which may contain wildcard characters
@@ -1051,7 +1053,7 @@ pure function to_fortran_name(string) result(res)
     res = replace(string, SPECIAL_CHARACTERS, '_')
 end function to_fortran_name
 
-function is_fortran_name(line) result (lout)
+elemental function is_fortran_name(line) result (lout)
 ! determine if a string is a valid Fortran name ignoring trailing spaces
 ! (but not leading spaces)
     character(len=*),parameter   :: int='0123456789'
@@ -1303,6 +1305,63 @@ pure logical function string_arrays_same(this,that)
 
 end function string_arrays_same
 
+! Remove all characters from a set from a string
+subroutine remove_characters_in_set(string,set,replace_with)
+    character(len=:), allocatable, intent(inout) :: string
+    character(*), intent(in) :: set
+    character, optional, intent(in) :: replace_with ! Replace with this character instead of removing
+
+    integer :: feed,length
+
+    if (.not.allocated(string)) return
+    if (len(set)<=0) return
+
+    length = len(string)
+    feed   = scan(string,set)
+
+    do while (length>0 .and. feed>0)
+
+        ! Remove heading
+        if (length==1) then
+            string = ""
+
+        elseif (feed==1) then
+            string = string(2:length)
+
+        ! Remove trailing
+        elseif (feed==length) then
+            string = string(1:length-1)
+
+        ! In between: replace with given character
+        elseif (present(replace_with)) then
+            string(feed:feed) = replace_with
+        ! Or just remove
+        else
+            string = string(1:feed-1)//string(feed+1:length)
+        end if
+
+        length = len(string)
+        feed   = scan(string,set)
+
+    end do
+
+end subroutine remove_characters_in_set
+
+! Remove all new line characters from the current string, replace them with spaces
+subroutine remove_newline_characters(string)
+    type(string_t), intent(inout) :: string
+
+    integer :: feed,length
+
+    character(*), parameter :: CRLF  = new_line('a')//achar(13)
+    character(*), parameter :: SPACE = ' '
+
+    call remove_characters_in_set(string%s,set=CRLF,replace_with=SPACE)
+
+end subroutine remove_newline_characters
+
+!>AUTHOR: John S. Urban
+!!LICENSE: Public Domain
 !>
 !!### NAME
 !!   notabs(3f) - [fpm_strings:NONALPHA] expand tab characters
@@ -1360,11 +1419,6 @@ end function string_arrays_same
 !!### SEE ALSO
 !!   GNU/Unix commands expand(1) and unexpand(1)
 !!
-!!### AUTHOR
-!!   John S. Urban
-!!
-!!### LICENSE
-!!   Public Domain
 elemental impure subroutine notabs(instr,outstr,ilen)
 
 ! ident_31="@(#)fpm_strings::notabs(3f): convert tabs to spaces while maintaining columns, remove CRLF chars"
@@ -1411,4 +1465,66 @@ elemental impure subroutine notabs(instr,outstr,ilen)
 
 end subroutine notabs
 
+!>AUTHOR: John S. Urban
+!!LICENSE: Public Domain
+!>
+!!##NAME
+!!    dilate(3f) - [M_strings:NONALPHA] expand tab characters
+!!    (LICENSE:PD)
+!!
+!!##SYNOPSIS
+!!
+!!    function dilate(INSTR) result(OUTSTR)
+!!
+!!     character(len=*),intent=(in)  :: INSTR
+!!     character(len=:),allocatable  :: OUTSTR
+!!
+!!##DESCRIPTION
+!!     dilate() converts tabs in INSTR to spaces in OUTSTR.  It assumes a
+!!     tab is set every 8 characters. Trailing spaces are removed.
+!!
+!!     In addition, trailing carriage returns and line feeds are removed
+!!     (they are usually a problem created by going to and from MSWindows).
+!!
+!!##OPTIONS
+!!     instr     Input line to remove tabs from
+!!
+!!##RESULTS
+!!     outstr    Output string with tabs expanded.
+!!
+!!##EXAMPLES
+!!
+!!   Sample program:
+!!
+!!    program demo_dilate
+!!
+!!    use M_strings, only : dilate
+!!    implicit none
+!!    character(len=:),allocatable :: in
+!!    integer                      :: i
+!!       in='  this is my string  '
+!!       ! change spaces to tabs to make a sample input
+!!       do i=1,len(in)
+!!          if(in(i:i) == ' ')in(i:i)=char(9)
+!!       enddo
+!!       write(*,'(a)')in,dilate(in)
+!!    end program demo_dilate
+!!
+function dilate(instr) result(outstr)
+
+   character(len=*), intent(in)  :: instr        ! input line to scan for tab characters
+   character(len=:), allocatable :: outstr       ! tab-expanded version of INSTR produced
+   integer                       :: i
+   integer                       :: icount
+   integer                       :: lgth
+   icount = 0
+   do i = 1, len(instr)
+      if (instr(i:i) == char(9)) icount = icount + 1
+   end do
+   allocate (character(len=(len(instr) + 8*icount)) :: outstr)
+   call notabs(instr, outstr, lgth)
+   outstr = outstr(:lgth)
+
+end function dilate
+
 end module fpm_strings
diff --git a/src/fpm_targets.f90 b/src/fpm_targets.f90
index 9c2ccc07cd..df0d58810f 100644
--- a/src/fpm_targets.f90
+++ b/src/fpm_targets.f90
@@ -32,6 +32,7 @@ module fpm_targets
 use fpm_filesystem, only: dirname, join_path, canon_path
 use fpm_strings, only: string_t, operator(.in.), string_cat, fnv_1a, resize, lower, str_ends_with
 use fpm_compiler, only: get_macros
+use fpm_sources, only: get_exe_name_with_suffix
 implicit none
 
 private
@@ -194,23 +195,17 @@ subroutine build_target_list(targets,model)
     type(fpm_model_t), intent(inout), target :: model
 
     integer :: i, j, n_source, exe_type
-    character(:), allocatable :: xsuffix, exe_dir, compile_flags
+    character(:), allocatable :: exe_dir, compile_flags
     logical :: with_lib
 
+    ! Initialize targets
+    allocate(targets(0))
+
     ! Check for empty build (e.g. header-only lib)
     n_source = sum([(size(model%packages(j)%sources), &
                       j=1,size(model%packages))])
 
-    if (n_source < 1) then
-        allocate(targets(0))
-        return
-    end if
-
-    if (get_os_type() == OS_WINDOWS) then
-        xsuffix = '.exe'
-    else
-        xsuffix = ''
-    end if
+    if (n_source < 1) return
 
     with_lib = any([((model%packages(j)%sources(i)%unit_scope == FPM_SCOPE_LIB, &
                       i=1,size(model%packages(j)%sources)), &
@@ -304,8 +299,7 @@ subroutine build_target_list(targets,model)
 
                     call add_target(targets,package=model%packages(j)%name,type = FPM_TARGET_EXECUTABLE,&
                                     link_libraries = sources(i)%link_libraries, &
-                                    output_name = join_path(exe_dir, &
-                                    sources(i)%exe_name//xsuffix))
+                                    output_name = join_path(exe_dir,get_exe_name_with_suffix(sources(i))))
 
                     associate(target => targets(size(targets))%ptr)
 
@@ -825,23 +819,22 @@ subroutine resolve_target_linking(targets, model)
 
         associate(target => targets(i)%ptr)
 
-            ! May have been previously allocated
+            ! If the main program is a C/C++ one, some compilers require additional linking flags, see
+            ! https://stackoverflow.com/questions/36221612/p3dfft-compilation-ifort-compiler-error-multiple-definiton-of-main
+            ! In this case, compile_flags were already allocated
             if (.not.allocated(target%compile_flags)) allocate(character(len=0) :: target%compile_flags)
 
             target%compile_flags = target%compile_flags//' '
 
-            if (target%target_type /= FPM_TARGET_C_OBJECT .and. target%target_type /= FPM_TARGET_CPP_OBJECT) then
-                target%compile_flags = target%compile_flags//model%fortran_compile_flags &
-                    & // get_feature_flags(model%compiler, target%features)
-            else if (target%target_type == FPM_TARGET_C_OBJECT) then
-                target%compile_flags = target%compile_flags//model%c_compile_flags
-            else if(target%target_type == FPM_TARGET_CPP_OBJECT) then
-                target%compile_flags = target%compile_flags//model%cxx_compile_flags
-            end if
-
-            ! If the main program is a C/C++ one, Intel compilers require additional
-            ! linking flag -nofor-main to avoid a "duplicate main" error, see
-            ! https://stackoverflow.com/questions/36221612/p3dfft-compilation-ifort-compiler-error-multiple-definiton-of-main
+            select case (target%target_type)
+               case (FPM_TARGET_C_OBJECT)
+                   target%compile_flags = target%compile_flags//model%c_compile_flags
+               case (FPM_TARGET_CPP_OBJECT)
+                   target%compile_flags = target%compile_flags//model%cxx_compile_flags
+               case default
+                   target%compile_flags = target%compile_flags//model%fortran_compile_flags &
+                                        & // get_feature_flags(model%compiler, target%features)
+            end select
 
             !> Get macros as flags.
             target%compile_flags = target%compile_flags // get_macros(model%compiler%id, &
@@ -876,7 +869,8 @@ subroutine resolve_target_linking(targets, model)
 
                 call get_link_objects(target%link_objects,target,is_exe=.true.)
 
-                local_link_flags = model%link_flags
+                local_link_flags = ""
+                if (allocated(model%link_flags)) local_link_flags = model%link_flags
                 target%link_flags = model%link_flags//" "//string_cat(target%link_objects," ")
 
                 if (allocated(target%link_libraries)) then
diff --git a/test/cli_test/cli_test.f90 b/test/cli_test/cli_test.f90
index 69fd433145..f5336b62ca 100644
--- a/test/cli_test/cli_test.f90
+++ b/test/cli_test/cli_test.f90
@@ -30,12 +30,13 @@ program main
 logical                              :: c_s,act_c_s          ; namelist/act_cli/act_c_s
 logical                              :: c_a,act_c_a          ; namelist/act_cli/act_c_a
 logical                              :: show_v,act_show_v    ; namelist/act_cli/act_show_v
-logical                              :: show_f_d,act_show_f_d; namelist/act_cli/act_show_f_d
+logical                              :: show_u_d,act_show_u_d; namelist/act_cli/act_show_u_d
+logical                              :: dry_run,act_dry_run  ; namelist/act_cli/act_dry_run
 character(len=:), allocatable        :: token, act_token     ; namelist/act_cli/act_token
 
 character(len=:), allocatable        :: profile,act_profile  ; namelist/act_cli/act_profile
 character(len=:), allocatable        :: args,act_args        ; namelist/act_cli/act_args
-namelist/expected/cmd,cstat,estat,w_e,w_t,c_s,c_a,name,profile,args,show_v,show_f_d,token
+namelist/expected/cmd,cstat,estat,w_e,w_t,c_s,c_a,name,profile,args,show_v,show_u_d,dry_run,token
 integer                              :: lun
 logical,allocatable                  :: tally(:)
 logical,allocatable                  :: subtally(:)
@@ -68,15 +69,16 @@ program main
 'CMD="test proj1 p2 project3 --profile release -- arg1 -x ""and a long one""", &
    &NAME="proj1","p2","project3",profile="release" ARGS="""arg1"" ""-x"" ""and a long one""",                         ', &
 
-'CMD="build",                                                      NAME= profile="",ARGS="",', &
-'CMD="build --profile release",                                    NAME= profile="release",ARGS="",', &
+'CMD="build",                                                      NAME=, profile="",ARGS="",', &
+'CMD="build --profile release",                                    NAME=, profile="release",ARGS="",', &
 
-'CMD="clean",                                                      NAME= ARGS="",', &
-'CMD="clean --skip",                                        C_S=T, NAME= ARGS="",', &
-'CMD="clean --all",                                         C_A=T, NAME= ARGS="",', &
-'CMD="publish --token abc --show-package-version",       SHOW_V=T, NAME= token="abc",ARGS="",', &
-'CMD="publish --token abc --show-form-data",           SHOW_F_D=T, NAME= token="abc",ARGS="",', &
-'CMD="publish --token abc",                                        NAME= token="abc",ARGS="",', &
+'CMD="clean",                                                      NAME=, ARGS="",', &
+'CMD="clean --skip",                                        C_S=T, NAME=, ARGS="",', &
+'CMD="clean --all",                                         C_A=T, NAME=, ARGS="",', &
+'CMD="publish --token abc --show-package-version",       SHOW_V=T, NAME=, token="abc",ARGS="",', &
+'CMD="publish --token abc --show-upload-data",           SHOW_U_D=T, NAME=, token="abc",ARGS="",', &
+'CMD="publish --token abc --dry-run",                    DRY_RUN=T, NAME=, token="abc",ARGS="",', &
+'CMD="publish --token abc",                                        NAME=, token="abc",ARGS="",', &
 ' ' ]
 character(len=256) :: readme(3)
 
@@ -110,7 +112,8 @@ program main
       c_s=.false.                    ! --skip
       c_a=.false.                    ! --all
       show_v=.false.                 ! --show-package-version
-      show_f_d=.false.               ! --show-form-data
+      show_u_d=.false.               ! --show-upload-data
+      dry_run=.false.                ! --dry-run
       token=''                       ! --token TOKEN
       args=repeat(' ',132)           ! -- ARGS
       cmd=repeat(' ',132)            ! the command line arguments to test
@@ -132,7 +135,8 @@ program main
              act_c_s=.false.
              act_c_a=.false.
              act_show_v=.false.
-             act_show_f_d=.false.
+             act_show_u_d=.false.
+             act_dry_run=.false.
              act_token=''
              act_args=repeat(' ',132)
              read(lun,nml=act_cli,iostat=ios,iomsg=message)
@@ -148,7 +152,8 @@ program main
              call test_test('WITH_TESTED',act_w_t.eqv.w_t)
              call test_test('WITH_TEST',act_w_t.eqv.w_t)
              call test_test('SHOW-PACKAGE-VERSION',act_show_v.eqv.show_v)
-             call test_test('SHOW-FORM-DATA',act_show_f_d.eqv.show_f_d)
+             call test_test('SHOW-UPLOAD-DATA',act_show_u_d.eqv.show_u_d)
+             call test_test('DRY-RUN',act_dry_run.eqv.dry_run)
              call test_test('TOKEN',act_token==token)
              call test_test('ARGS',act_args==args)
              if(all(subtally))then
@@ -237,7 +242,8 @@ subroutine parse()
 act_c_s=.false.
 act_c_a=.false.
 act_show_v=.false.
-act_show_f_d=.false.
+act_show_u_d=.false.
+act_dry_run=.false.
 act_token=''
 act_profile=''
 
@@ -251,18 +257,19 @@ subroutine parse()
 type is (fpm_run_settings)
     act_profile=settings%profile
     act_name=settings%name
-    act_args=settings%args
+    if (allocated(settings%args)) act_args=settings%args
 type is (fpm_test_settings)
     act_profile=settings%profile
     act_name=settings%name
-    act_args=settings%args
+    if (allocated(settings%args)) act_args=settings%args
 type is (fpm_clean_settings)
     act_c_s=settings%clean_skip
     act_c_a=settings%clean_call
 type is (fpm_install_settings)
 type is (fpm_publish_settings)
     act_show_v=settings%show_package_version
-    act_show_f_d=settings%show_form_data
+    act_show_u_d=settings%show_upload_data
+    act_dry_run=settings%is_dry_run
     act_token=settings%token
 end select
 
diff --git a/test/fpm_test/test_manifest.f90 b/test/fpm_test/test_manifest.f90
index 58f6ad7e22..ddabe3cf49 100644
--- a/test/fpm_test/test_manifest.f90
+++ b/test/fpm_test/test_manifest.f90
@@ -493,7 +493,7 @@ subroutine test_profiles(error)
         type(package_config_t) :: package
         character(len=*), parameter :: manifest = 'fpm-profiles.toml'
         integer :: unit
-        character(:), allocatable :: profile_name, compiler, flags
+        character(:), allocatable :: profile_name, compiler
         logical :: profile_found
         type(profile_config_t) :: chosen_profile
 
@@ -555,8 +555,9 @@ subroutine test_profiles(error)
         profile_name = 'debug'
         compiler = 'ifort'
         call find_profile(package%profiles, profile_name, compiler, 3, profile_found, chosen_profile)
-        if (.not.(chosen_profile%flags.eq.' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl /traceback')) then
-            call test_failed(error, "Failed to load built-in profile"//flags)
+        if (.not.(chosen_profile%flags.eq.&
+            ' /warn:all /check:all /error-limit:1 /Od /Z7 /assume:byterecl /standard-semantics /traceback')) then
+            call test_failed(error, "Failed to load built-in profile "//profile_name)
             return
         end if
 
@@ -1418,7 +1419,7 @@ subroutine test_macro_parsing(error)
         type(error_t), allocatable, intent(out) :: error
 
         type(package_config_t) :: package
-        character(:), allocatable :: temp_file
+        character(:), allocatable :: temp_file,pkg_ver
         integer :: unit
         integer(compiler_enum)  :: id
 
@@ -1437,7 +1438,9 @@ subroutine test_macro_parsing(error)
 
         if (allocated(error)) return
 
-        if (get_macros(id, package%preprocess(1)%macros, package%version%s()) /= " -DFOO -DBAR=2 -DVERSION=0.1.0") then
+        pkg_ver = package%version%s()
+
+        if (get_macros(id, package%preprocess(1)%macros, pkg_ver) /= " -DFOO -DBAR=2 -DVERSION=0.1.0") then
             call test_failed(error, "Macros were not parsed correctly")
         end if
 
@@ -1450,12 +1453,13 @@ subroutine test_macro_parsing_dependency(error)
         !> Error handling
         type(error_t), allocatable, intent(out) :: error
 
-        character(len=:), allocatable :: macrosPackage, macrosDependency
+        character(len=:), allocatable :: macros_package, macros_dependency
 
         type(package_config_t) :: package, dependency
 
         character(:), allocatable :: toml_file_package
         character(:), allocatable :: toml_file_dependency
+        character(:), allocatable :: pkg_ver,dep_ver
 
         integer :: unit
         integer(compiler_enum)  :: id
@@ -1492,10 +1496,12 @@ subroutine test_macro_parsing_dependency(error)
 
         if (allocated(error)) return
 
-        macrosPackage = get_macros(id, package%preprocess(1)%macros, package%version%s())
-        macrosDependency = get_macros(id, dependency%preprocess(1)%macros, dependency%version%s())
+        pkg_ver = package%version%s()
+        dep_ver = dependency%version%s()
 
-        if (macrosPackage == macrosDependency) then
+        macros_package = get_macros(id, package%preprocess(1)%macros, pkg_ver)
+        macros_dependency = get_macros(id, dependency%preprocess(1)%macros, dep_ver)
+        if (macros_package == macros_dependency) then
             call test_failed(error, "Macros of package and dependency should not be equal")
         end if
 
diff --git a/test/fpm_test/test_os.f90 b/test/fpm_test/test_os.f90
index d573ac0b78..71989167f5 100644
--- a/test/fpm_test/test_os.f90
+++ b/test/fpm_test/test_os.f90
@@ -1,7 +1,7 @@
 module test_os
     use testsuite, only: new_unittest, unittest_t, error_t, test_failed
-    use fpm_filesystem, only: env_variable, join_path, mkdir, os_delete_dir, is_dir, get_local_prefix, get_home
-    use fpm_environment, only: os_is_unix
+    use fpm_filesystem, only: join_path, mkdir, os_delete_dir, is_dir, get_local_prefix, get_home
+    use fpm_environment, only: os_is_unix, get_env
     use fpm_os, only: get_absolute_path, get_absolute_path_by_cd, get_current_directory
 
     implicit none
@@ -91,6 +91,7 @@ subroutine tilde_correct_separator(error)
         end if
 
         call get_absolute_path('~'//separator, result, error)
+        if (allocated(error)) return
 
         call get_home(home, error)
         if (allocated(error)) return
@@ -133,19 +134,20 @@ subroutine abs_path_nonexisting(error)
     subroutine abs_path_root(error)
         type(error_t), allocatable, intent(out) :: error
 
-        character(len=:), allocatable :: home_drive, home_path, result
+        character(len=:), allocatable :: home_path, result
 
         if (os_is_unix()) then
             call get_absolute_path('/', result, error)
+            if (allocated(error)) return
 
             if (result /= '/') then
                 call test_failed(error, "Result '"//result//"' doesn't equal input value: '/'"); return
             end if
         else
-            call env_variable(home_drive, 'HOMEDRIVE')
-            home_path = home_drive//'\'
+            home_path = get_env('HOMEDRIVE','') //'\'
 
             call get_absolute_path(home_path, result, error)
+            if (allocated(error)) return
 
             if (result /= home_path) then
                 call test_failed(error, "Result '"//result//"' doesn't equal input value: '"//home_path//"'"); return
@@ -174,7 +176,7 @@ subroutine abs_path_home(error)
     subroutine abs_path_cd_root(error)
         type(error_t), allocatable, intent(out) :: error
 
-        character(len=:), allocatable :: home_drive, home_path, current_dir_before, current_dir_after, result
+        character(len=:), allocatable :: home_path, current_dir_before, current_dir_after, result
 
         call get_current_directory(current_dir_before, error)
         if (allocated(error)) return
@@ -186,8 +188,7 @@ subroutine abs_path_cd_root(error)
                 call test_failed(error, "Result '"//result//"' doesn't equal input value: '/'"); return
             end if
         else
-            call env_variable(home_drive, 'HOMEDRIVE')
-            home_path = home_drive//'\'
+            home_path = get_env('HOMEDRIVE','')//'\'
 
             call get_absolute_path_by_cd(home_path, result, error)
 
diff --git a/test/fpm_test/test_package_dependencies.f90 b/test/fpm_test/test_package_dependencies.f90
index 425e124dd4..f87f3f02f4 100644
--- a/test/fpm_test/test_package_dependencies.f90
+++ b/test/fpm_test/test_package_dependencies.f90
@@ -7,8 +7,10 @@ module test_package_dependencies
   use fpm_os, only: get_current_directory
   use fpm_dependency
   use fpm_manifest_dependency
+  use fpm_manifest_metapackages, only: metapackage_config_t
+  use fpm_manifest, only: package_config_t, get_package_data
   use fpm_toml
-  use fpm_settings, only: fpm_global_settings, get_registry_settings
+  use fpm_settings, only: fpm_global_settings, get_registry_settings, get_global_settings
   use fpm_downloader, only: downloader_t
   use fpm_versioning, only: version_t
   use jonquil, only: json_object, json_value, json_loads, cast_to_object
@@ -45,10 +47,11 @@ subroutine collect_package_dependencies(tests)
         & new_unittest("status-after-load", test_status), &
         & new_unittest("add-dependencies", test_add_dependencies), &
         & new_unittest("update-dependencies", test_update_dependencies), &
+        & new_unittest("metapackage-override", test_metapackage_override), &
         & new_unittest("do-not-update-dependencies", test_non_updated_dependencies), &
         & new_unittest("registry-dir-not-found", registry_dir_not_found, should_fail=.true.), &
         & new_unittest("no-versions-in-registry", no_versions_in_registry, should_fail=.true.), &
-     & new_unittest("local-registry-specified-version-not-found", local_registry_specified_version_not_found, should_fail=.true.), &
+  & new_unittest("local-registry-specified-version-not-found", local_registry_specified_version_not_found, should_fail=.true.), &
         & new_unittest("local-registry-specified-no-manifest", local_registry_specified_no_manifest, should_fail=.true.), &
         & new_unittest("local-registry-specified-has-manifest", local_registry_specified_has_manifest), &
         & new_unittest("local-registry-specified-not-a-dir", local_registry_specified_not_a_dir, should_fail=.true.), &
@@ -245,7 +248,8 @@ subroutine test_add_dependencies(error)
       return
     end if
 
-    call deps%resolve(".", error)
+    ! Do not use polymorphic version due to Ifort issue
+    call resolve_dependencies(deps, ".", error)
     if (allocated(error)) return
 
     if (.not. deps%finished()) then
@@ -330,7 +334,6 @@ subroutine test_non_updated_dependencies(error)
       return
     end if
 
-
     ! Test that dependency 3 is flagged as "not update"
     if (manifest_deps%dep(3)%update) then
       call test_failed(error, "Updated dependency (git rev) detected, should not be")
@@ -420,6 +423,70 @@ subroutine test_update_dependencies(error)
 
   end subroutine test_update_dependencies
 
+
+  !> Test that a metapackage is overridden if a regular dependency is provided
+  subroutine test_metapackage_override(error)
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    type(toml_table) :: manifest
+    type(toml_table), pointer :: ptr
+    type(dependency_config_t), allocatable :: deps(:)
+    type(metapackage_config_t) :: meta
+    logical :: found
+    integer :: i
+
+    ! Create a dummy manifest, with a standard git dependency for stdlib
+    manifest = toml_table()
+    call add_table(manifest, "stdlib", ptr)
+    call set_value(ptr, "git", "https://github.com/fortran-lang/stdlib")
+    call set_value(ptr, "branch", "stdlib-fpm")
+
+    ! Load dependencies from manifest
+    call new_dependencies(deps, manifest, meta=meta, error=error)
+    if (allocated(error)) return
+
+    ! Check that stdlib is in the regular dependency list
+    found = .false.
+    do i=1,size(deps)
+       if (deps(i)%name=="stdlib") found = .true.
+    end do
+
+    if (.not.found) then
+        call test_failed(error,"standard git-based dependency for stdlib not recognized")
+        return
+    end if
+    call manifest%destroy()
+
+
+    ! Create a dummy manifest, with a version-based metapackage dependency for stdlib
+    manifest = toml_table()
+    call set_value(manifest, "stdlib", "*")
+
+    ! Load dependencies from manifest
+    call new_dependencies(deps, manifest, meta=meta, error=error)
+    if (allocated(error)) return
+
+    ! Check that stdlib is in the metapackage config and not the standard dependencies
+    found = .false.
+    do i=1,size(deps)
+       if (deps(i)%name=="stdlib") found = .true.
+    end do
+
+    if (found) then
+        call test_failed(error,"metapackage dependency for stdlib should not be in the tree")
+        return
+    end if
+    call manifest%destroy()
+
+    if (.not.meta%stdlib%on) then
+        call test_failed(error,"metapackage dependency for stdlib should be in the metapackage config")
+        return
+    end if
+
+  end subroutine test_metapackage_override
+
   !> Directories for namespace and package name not found in path registry.
   subroutine registry_dir_not_found(error)
     type(error_t), allocatable, intent(out) :: error
@@ -1425,6 +1492,30 @@ subroutine resolve_dependency_once(self, dependency, global_settings, root, erro
 
   end subroutine resolve_dependency_once
 
+  !> Resolve all dependencies in the tree
+  subroutine resolve_dependencies(self, root, error)
+    !> Instance of the dependency tree
+    type(mock_dependency_tree_t), intent(inout) :: self
+    !> Current installation prefix
+    character(len=*), intent(in) :: root
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    type(fpm_global_settings) :: global_settings
+    integer :: ii
+
+    call get_global_settings(global_settings, error)
+    if (allocated(error)) return
+
+    do ii = 1, self%ndep
+      call resolve_dependency_once(self, self%dep(ii), global_settings, root, error)
+      if (allocated(error)) exit
+    end do
+
+    if (allocated(error)) return
+
+  end subroutine resolve_dependencies
+
   subroutine delete_tmp_folder
     if (is_dir(tmp_folder)) call os_delete_dir(os_is_unix(), tmp_folder)
   end
diff --git a/test/fpm_test/test_source_parsing.f90 b/test/fpm_test/test_source_parsing.f90
index 45fc5c6474..c407d0c857 100644
--- a/test/fpm_test/test_source_parsing.f90
+++ b/test/fpm_test/test_source_parsing.f90
@@ -2,11 +2,12 @@
 module test_source_parsing
     use testsuite, only : new_unittest, unittest_t, error_t, test_failed
     use fpm_filesystem, only: get_temp_filename
-    use fpm_source_parsing, only: parse_f_source, parse_c_source
+    use fpm_source_parsing, only: parse_f_source, parse_c_source, parse_use_statement
     use fpm_model, only: srcfile_t, FPM_UNIT_PROGRAM, FPM_UNIT_MODULE, &
                          FPM_UNIT_SUBMODULE, FPM_UNIT_SUBPROGRAM, FPM_UNIT_CSOURCE, &
                          FPM_UNIT_CPPSOURCE
-    use fpm_strings, only: operator(.in.)
+    use fpm_strings, only: operator(.in.), lower
+    use fpm_error, only: file_parse_error, fatal_error
     implicit none
     private
 
@@ -14,7 +15,6 @@ module test_source_parsing
 
 contains
 
-
     !> Collect all exported unit tests
     subroutine collect_source_parsing(testsuite)
 
@@ -24,6 +24,7 @@ subroutine collect_source_parsing(testsuite)
         testsuite = [ &
             & new_unittest("modules-used", test_modules_used), &
             & new_unittest("intrinsic-modules-used", test_intrinsic_modules_used), &
+            & new_unittest("nonintrinsic-modules-used", test_nonintrinsic_modules_used), &
             & new_unittest("include-stmt", test_include_stmt), &
             & new_unittest("program", test_program), &
             & new_unittest("module", test_module), &
@@ -42,7 +43,8 @@ subroutine collect_source_parsing(testsuite)
             & new_unittest("invalid-module", &
                            test_invalid_module, should_fail=.true.), &
             & new_unittest("invalid-submodule", &
-                           test_invalid_submodule, should_fail=.true.) &
+                           test_invalid_submodule, should_fail=.true.), &
+            & new_unittest("use-statement",test_use_statement) &
             ]
 
     end subroutine collect_source_parsing
@@ -191,6 +193,78 @@ subroutine test_intrinsic_modules_used(error)
     end subroutine test_intrinsic_modules_used
 
 
+    !> Check that intrinsic module names are not ignored if declared non_intrinsic
+    subroutine test_nonintrinsic_modules_used(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: unit
+        character(:), allocatable :: temp_file
+        type(srcfile_t), allocatable :: f_source
+
+        allocate(temp_file, source=get_temp_filename())
+
+        open(file=temp_file, newunit=unit)
+        write(unit, '(a)') &
+            & 'program test', &
+            & ' use, non_intrinsic :: iso_c_binding', &
+            & ' use,     intrinsic :: iso_fortran_env', &
+            & ' use, non_intrinsic :: ieee_arithmetic', &
+            & ' use, non_intrinsic :: ieee_exceptions', &
+            & ' use, non_intrinsic :: ieee_features', &
+            & ' use, non_intrinsic :: my_module', &
+            & ' implicit none', &
+            & 'end program test'
+        close(unit)
+
+        f_source = parse_f_source(temp_file,error)
+        if (allocated(error)) then
+            return
+        end if
+
+        if (size(f_source%modules_provided) /= 0) then
+            call test_failed(error,'Unexpected modules_provided - expecting zero')
+            return
+        end if
+
+        if (size(f_source%modules_used) /= 5) then
+            call test_failed(error,'Incorrect number of modules_used - expecting five')
+            return
+        end if
+
+        if (.not. ('iso_c_binding' .in. f_source%modules_used)) then
+            call test_failed(error,'Non-Intrinsic module found in modules_used')
+            return
+        end if
+
+        if ('iso_fortran_env' .in. f_source%modules_used) then
+            call test_failed(error,'Intrinsic module found in modules_used')
+            return
+        end if
+
+        if (.not. ('ieee_arithmetic' .in. f_source%modules_used)) then
+            call test_failed(error,'Non-Intrinsic module not found in modules_used')
+            return
+        end if
+
+        if (.not. ('ieee_exceptions' .in. f_source%modules_used)) then
+            call test_failed(error,'Non-Intrinsic module not found in modules_used')
+            return
+        end if
+
+        if (.not. ('ieee_features' .in. f_source%modules_used)) then
+            call test_failed(error,'Non-Intrinsic module not found in modules_used')
+            return
+        end if
+
+        if (.not. ('my_module' .in. f_source%modules_used)) then
+            call test_failed(error,'Non-Intrinsic module not found in modules_used')
+            return
+        end if
+
+    end subroutine test_nonintrinsic_modules_used
+
     !> Check parsing of include statements
     subroutine test_include_stmt(error)
 
@@ -971,6 +1045,65 @@ subroutine test_invalid_submodule(error)
 
     end subroutine test_invalid_submodule
 
+    !> Parse several USE statements
+    subroutine test_use_statement(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(*), parameter :: filename='test_use_statement'
+        character(:), allocatable :: line,module_name
+
+        logical :: used,is_intrinsic
+
+        line = 'use, intrinsic:: iso_fortran_env'
+        call parse_use_statement(filename,0,line,used,is_intrinsic,module_name,error)
+        if (allocated(error)) return
+
+        if (.not. (used .and. &
+                   is_intrinsic .and. &
+                   module_name=='iso_fortran_env' .and. &
+                   used)) then
+          call fatal_error(error,'USE statement failed parsing <'//line//'>')
+          return
+        endif
+
+        line = 'use, non_intrinsic :: iso_fortran_env'
+        call parse_use_statement(filename,0,line,used,is_intrinsic,module_name,error)
+        if (allocated(error)) return
+
+        if (.not. (used .and. &
+                   (.not.is_intrinsic) .and. &
+                   module_name=='iso_fortran_env' .and. &
+                   used)) then
+          call fatal_error(error,'USE statement failed parsing <'//line//'>')
+          return
+        endif
+
+        line = 'use, non_intrinsic :: my_fortran_module'
+        call parse_use_statement(filename,0,line,used,is_intrinsic,module_name,error)
+        if (allocated(error)) return
+
+        if (.not. (used .and. &
+                   (.not.is_intrinsic) .and. &
+                   module_name=='my_fortran_module' .and. &
+                   used)) then
+          call fatal_error(error,'USE statement failed parsing <'//line//'>')
+          return
+        endif
+
+        line = 'use, intrinsic :: my_fortran_module'
+        call parse_use_statement(filename,0,line,used,is_intrinsic,module_name,error)
+
+        ! This is not an intrinsic module: should detect an error
+        if (.not. allocated(error)) then
+          call fatal_error(error,'Did not catch invalid intrinsic module in <'//line//'>')
+          return
+        else
+           deallocate(error)
+        endif
+
+    end subroutine test_use_statement
 
 
 end module test_source_parsing