diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..8ac6b8c498
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index 08b8ed725a..465d2558e5 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -22,7 +22,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-11, windows-latest]
-        gcc_v: [10] # Version of GFortran we want to use.
+        gcc_v: [10,11,12,13] # Version of GFortran we want to use.
         include:
         - os: ubuntu-latest
           os-arch: linux-x86_64
@@ -43,7 +43,7 @@ jobs:
 
     steps:
     - name: Checkout code
-      uses: actions/checkout@v1
+      uses: actions/checkout@v4
 
     - name: Install GFortran macOS
       if: contains(matrix.os, 'macos')
@@ -81,7 +81,7 @@ jobs:
 
     # Phase 1: Bootstrap fpm with existing version
     - name: Install fpm
-      uses: fortran-lang/setup-fpm@v3
+      uses: fortran-lang/setup-fpm@v5
       with:
         fpm-version: 'v0.8.0'
 
@@ -194,7 +194,7 @@ jobs:
       - build
     
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
     - name: Download Artifacts
       uses: actions/download-artifact@v2
@@ -277,7 +277,7 @@ jobs:
       env:
         DEPLOY_BRANCH: ${{ secrets.DEPLOY_BRANCH && contains(github.ref, secrets.DEPLOY_BRANCH) && 1 || 0 }}
 
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       if: ${{ github.event_name == 'push' }}
 
     - name: Download Artifacts
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 2ecb4183a1..e3418fe23a 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -6,8 +6,8 @@ jobs:
   build-and-deploy:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v1
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
diff --git a/.github/workflows/meta.yml b/.github/workflows/meta.yml
index 86b5215c53..bdc572c027 100644
--- a/.github/workflows/meta.yml
+++ b/.github/workflows/meta.yml
@@ -35,8 +35,6 @@ jobs:
             mpi: openmpi
           - os: ubuntu-latest
             mpi: mpich
-          - os: windows-latest
-            mpi: msmpi
           - os: macos-latest
             mpi: openmpi
           - os: macos-latest
@@ -45,7 +43,7 @@ jobs:
 
     steps:
     - name: Checkout code
-      uses: actions/checkout@v1
+      uses: actions/checkout@v4
 
     - name: (Ubuntu) setup gcc version
       if: contains(matrix.os,'ubuntu')
@@ -69,7 +67,6 @@ jobs:
           wget
           unzip
           curl
-          gcc-fortran
 
     - name: (Windows) Setup VS Build environment
       if: contains(matrix.os,'windows') && contains(matrix.mpi,'intel')
@@ -87,7 +84,7 @@ jobs:
         Remove-Item "oneAPI" -Force -Recurse
 
     - name: (Ubuntu) Install gfortran
-      if: contains(matrix.os,'ubuntu') && (!contains(matrix.mpi,'intel'))
+      if: contains(matrix.os,'ubuntu') 
       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} \
@@ -107,16 +104,14 @@ jobs:
       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
+        wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
+        echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] 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
+      timeout-minutes: 15
+      run: sudo apt-get install intel-oneapi-compiler-dpcpp-cpp-2023.1.0 intel-oneapi-compiler-fortran-2023.1.0 intel-oneapi-mpi-devel ninja-build
 
     - name: (Ubuntu) Setup Intel oneAPI environment
       if: contains(matrix.os,'ubuntu') && contains(matrix.mpi,'intel')
@@ -153,6 +148,7 @@ jobs:
       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 "/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
@@ -203,7 +199,7 @@ jobs:
 
     # Phase 1: Bootstrap fpm with existing version
     - name: Install fpm
-      uses: fortran-lang/setup-fpm@v3
+      uses: fortran-lang/setup-fpm@v5
       with:
         fpm-version: 'v0.8.0'
 
@@ -213,14 +209,6 @@ jobs:
         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
@@ -304,6 +292,14 @@ jobs:
       env:
         EXE: fpm-${{ env.VERSION }}-${{ matrix.os-arch }}${{ matrix.exe }}
 
+    - name: Use Intel compiler for the metapackage tests
+      if: contains(matrix.mpi,'intel')
+      shell: bash
+      run: |
+        echo "FPM_FC=ifx" >> $GITHUB_ENV
+        echo "FPM_CC=icx"   >> $GITHUB_ENV
+        echo "FPM_CXX=icpx" >> $GITHUB_ENV
+
     - name: Run metapackage tests using the release version
       shell: bash
       run: |
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b4b030d5a9..2a37ca316b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,7 +17,7 @@ jobs:
       FORMAT: ${{ matrix.format }}
     steps:
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
@@ -44,7 +44,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
@@ -67,7 +67,7 @@ jobs:
         patch -p1 < ./ci/single-file.patch
 
     - name: Install fpm
-      uses: fortran-lang/setup-fpm@v3
+      uses: fortran-lang/setup-fpm@v5
       with:
         fpm-version: 'v0.8.0'
 
@@ -124,7 +124,7 @@ jobs:
       env:
         DEPLOY_BRANCH: ${{ secrets.DEPLOY_BRANCH && contains(github.ref, secrets.DEPLOY_BRANCH) && 1 || 0 }}
 
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       if: ${{ github.event_name == 'push' }}
 
     - name: Download Artifacts
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/app/main.f90 b/app/main.f90
index 95df065097..4bd3ac5e33 100644
--- a/app/main.f90
+++ b/app/main.f90
@@ -4,6 +4,7 @@ program main
         fpm_cmd_settings, &
         fpm_new_settings, &
         fpm_build_settings, &
+        fpm_export_settings, &
         fpm_run_settings, &
         fpm_test_settings, &
         fpm_install_settings, &
@@ -15,6 +16,7 @@ program main
 use fpm_filesystem, only: exists, parent_dir, join_path
 use fpm, only: cmd_build, cmd_run, cmd_clean
 use fpm_cmd_install, only: cmd_install
+use fpm_cmd_export, only: cmd_export
 use fpm_cmd_new, only: cmd_new
 use fpm_cmd_update, only : cmd_update
 use fpm_cmd_publish, only: cmd_publish
@@ -76,6 +78,8 @@ program main
     call cmd_run(settings,test=.false.)
 type is (fpm_test_settings)
     call cmd_run(settings,test=.true.)
+type is (fpm_export_settings)
+    call cmd_export(settings)
 type is (fpm_install_settings)
     call cmd_install(settings)
 type is (fpm_update_settings)
diff --git a/ci/run_tests.sh b/ci/run_tests.sh
index 987b282449..c31f134312 100755
--- a/ci/run_tests.sh
+++ b/ci/run_tests.sh
@@ -150,6 +150,14 @@ pushd preprocess_cpp_deps
 "$fpm" build
 popd
 
+pushd preprocess_cpp_suffix
+"$fpm" run
+popd
+
+pushd preprocess_per_dependency
+"$fpm" run
+popd
+
 pushd preprocess_hello
 "$fpm" build
 popd
diff --git a/example_packages/preprocess_cpp_suffix/.gitignore b/example_packages/preprocess_cpp_suffix/.gitignore
new file mode 100644
index 0000000000..a007feab07
--- /dev/null
+++ b/example_packages/preprocess_cpp_suffix/.gitignore
@@ -0,0 +1 @@
+build/*
diff --git a/example_packages/preprocess_cpp_suffix/app/main.f90 b/example_packages/preprocess_cpp_suffix/app/main.f90
new file mode 100644
index 0000000000..7d77b56a06
--- /dev/null
+++ b/example_packages/preprocess_cpp_suffix/app/main.f90
@@ -0,0 +1,8 @@
+program test_preprocess_suffix
+   use preprocess_cpp
+#ifndef TESTMACRO
+   stop -1
+#else
+   stop 0
+#endif   
+end program test_preprocess_suffix
diff --git a/example_packages/preprocess_cpp_suffix/fpm.toml b/example_packages/preprocess_cpp_suffix/fpm.toml
new file mode 100644
index 0000000000..6399f1a67d
--- /dev/null
+++ b/example_packages/preprocess_cpp_suffix/fpm.toml
@@ -0,0 +1,7 @@
+name = "preprocess_cpp_suffix"
+version = "1"
+
+[preprocess]
+[preprocess.cpp]
+macros = ["TESTMACRO", "TESTMACRO2=3", "TESTMACRO3={version}"]
+suffixes = ["fpp"]
diff --git a/example_packages/preprocess_cpp_suffix/src/preprocess_cpp.fpp b/example_packages/preprocess_cpp_suffix/src/preprocess_cpp.fpp
new file mode 100644
index 0000000000..d7ab5d1485
--- /dev/null
+++ b/example_packages/preprocess_cpp_suffix/src/preprocess_cpp.fpp
@@ -0,0 +1,22 @@
+module preprocess_cpp
+   implicit none
+   private
+
+   public :: say_hello
+contains
+   subroutine say_hello
+      print *, "Hello, preprocess_cpp!"
+#ifndef TESTMACRO
+      This breaks the build.
+#endif
+
+#if TESTMACRO2 != 3
+      This breaks the build.
+#endif
+
+#if TESTMACRO3 != 1
+      This breaks the build.
+#endif
+
+   end subroutine say_hello
+end module preprocess_cpp
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 90b1712f66..2036d0c3bc 100644
--- a/fpm.toml
+++ b/fpm.toml
@@ -1,5 +1,5 @@
 name = "fpm"
-version = "0.9.0"
+version = "0.10.1"
 license = "MIT"
 author = "fpm maintainers"
 maintainer = ""
@@ -17,7 +17,9 @@ 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"
+fortran-shlex.git = "https://github.com/perazz/fortran-shlex"
+fortran-shlex.tag = "1.0.1"
 
 [[test]]
 name = "cli-test"
diff --git a/install.sh b/install.sh
old mode 100644
new mode 100755
diff --git a/manifest-reference.md b/manifest-reference.md
index 5f203f9826..45cf3e6d62 100644
--- a/manifest-reference.md
+++ b/manifest-reference.md
@@ -1,3 +1,3 @@
 # 301 - Moved
 
-This document now lives at https://fpm.fortran-lang.org/en/spec/manifest.html.
+This document now lives at https://fpm.fortran-lang.org/spec/manifest.html
diff --git a/src/filesystem_utilities.c b/src/filesystem_utilities.c
index 57b863b8ce..73f0c8aaa9 100644
--- a/src/filesystem_utilities.c
+++ b/src/filesystem_utilities.c
@@ -1,7 +1,7 @@
 #include <sys/stat.h>
 #include <dirent.h>
 
-#if defined(__APPLE__) && !defined(__aarch64__) && !defined(__POWERPC__)
+#if defined(__APPLE__) && !defined(__aarch64__) && !defined(__ppc__) && !defined(__i386__)
 DIR * opendir$INODE64( const char * dirName );
 struct dirent * readdir$INODE64( DIR * dir );
 #define opendir opendir$INODE64
diff --git a/src/fpm.f90 b/src/fpm.f90
index e878ea2b9b..de8bd43f4d 100644
--- a/src/fpm.f90
+++ b/src/fpm.f90
@@ -21,10 +21,14 @@ module fpm
 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,intrinsic :: iso_fortran_env, only : stdin=>input_unit,   &
-                                       & stdout=>output_unit, &
-                                       & stderr=>error_unit
+use fpm_toml, only: name_is_json
+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
+use fpm_settings, only: fpm_global_settings, get_global_settings
+
 implicit none
 private
 public :: cmd_build, cmd_run, cmd_clean
@@ -108,20 +112,24 @@ subroutine build_model(model, settings, package, error)
             end associate
             model%packages(i)%version = package%version%s()
 
+            !> Add this dependency's manifest macros
+            call model%packages(i)%preprocess%destroy()
+
             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
-                        end if
-                    else
-                        write(stderr, '(a)') 'Warning: Preprocessor ' // package%preprocess(i)%name // &
-                            ' is not supported; will ignore it'
-                    end if
+                    call model%packages(i)%preprocess%add_config(dependency%preprocess(j))
+                end do
+            end if
+
+            !> Add this dependency's package-level macros
+            if (allocated(dep%preprocess)) then
+                do j = 1, size(dep%preprocess)
+                    call model%packages(i)%preprocess%add_config(dep%preprocess(j))
                 end do
             end if
 
+            if (model%packages(i)%preprocess%is_cpp()) has_cpp = .true.
+
             if (.not.allocated(model%packages(i)%sources)) allocate(model%packages(i)%sources(0))
 
             if (allocated(dependency%library)) then
@@ -130,7 +138,7 @@ subroutine build_model(model, settings, package, error)
                     lib_dir = join_path(dep%proj_dir, dependency%library%source_dir)
                     if (is_dir(lib_dir)) then
                         call add_sources_from_dir(model%packages(i)%sources, lib_dir, FPM_SCOPE_LIB, &
-                            error=error)
+                            with_f_ext=model%packages(i)%preprocess%suffixes, error=error)
                         if (allocated(error)) exit
                     end if
                 end if
@@ -168,7 +176,8 @@ subroutine build_model(model, settings, package, error)
     ! Add sources from executable directories
     if (is_dir('app') .and. package%build%auto_executables) then
         call add_sources_from_dir(model%packages(1)%sources,'app', FPM_SCOPE_APP, &
-                                   with_executables=.true., error=error)
+                                   with_executables=.true., with_f_ext=model%packages(1)%preprocess%suffixes,&
+                                   error=error)
 
         if (allocated(error)) then
             return
@@ -177,7 +186,8 @@ subroutine build_model(model, settings, package, error)
     end if
     if (is_dir('example') .and. package%build%auto_examples) then
         call add_sources_from_dir(model%packages(1)%sources,'example', FPM_SCOPE_EXAMPLE, &
-                                   with_executables=.true., error=error)
+                                  with_executables=.true., &
+                                  with_f_ext=model%packages(1)%preprocess%suffixes,error=error)
 
         if (allocated(error)) then
             return
@@ -186,7 +196,8 @@ subroutine build_model(model, settings, package, error)
     end if
     if (is_dir('test') .and. package%build%auto_tests) then
         call add_sources_from_dir(model%packages(1)%sources,'test', FPM_SCOPE_TEST, &
-                                   with_executables=.true., error=error)
+                                  with_executables=.true., &
+                                  with_f_ext=model%packages(1)%preprocess%suffixes,error=error)
 
         if (allocated(error)) then
             return
@@ -196,6 +207,7 @@ subroutine build_model(model, settings, package, error)
     if (allocated(package%executable)) then
         call add_executable_sources(model%packages(1)%sources, package%executable, FPM_SCOPE_APP, &
                                      auto_discover=package%build%auto_executables, &
+                                     with_f_ext=model%packages(1)%preprocess%suffixes, &
                                      error=error)
 
         if (allocated(error)) then
@@ -206,6 +218,7 @@ subroutine build_model(model, settings, package, error)
     if (allocated(package%example)) then
         call add_executable_sources(model%packages(1)%sources, package%example, FPM_SCOPE_EXAMPLE, &
                                      auto_discover=package%build%auto_examples, &
+                                     with_f_ext=model%packages(1)%preprocess%suffixes, &
                                      error=error)
 
         if (allocated(error)) then
@@ -216,6 +229,7 @@ subroutine build_model(model, settings, package, error)
     if (allocated(package%test)) then
         call add_executable_sources(model%packages(1)%sources, package%test, FPM_SCOPE_TEST, &
                                      auto_discover=package%build%auto_tests, &
+                                     with_f_ext=model%packages(1)%preprocess%suffixes, &
                                      error=error)
 
         if (allocated(error)) then
@@ -438,6 +452,12 @@ subroutine cmd_build(settings)
     call fpm_stop(1,'*cmd_build* Target error: '//error%message)
 end if
 
+!> Dump model to file
+if (len_trim(settings%dump)>0) then
+    call model%dump(trim(settings%dump),error,json=name_is_json(trim(settings%dump)))
+    if (allocated(error)) call fpm_stop(1,'*cmd_build* Model dump error: '//error%message)
+endif
+
 if(settings%list)then
     do i=1,size(targets)
         write(stderr,*) targets(i)%ptr%output_file
@@ -493,7 +513,7 @@ subroutine cmd_run(settings,test)
     ! Enumerate executable targets to run
     col_width = -1
     found(:) = .false.
-    allocate(executables(0))
+    allocate(executables(size(settings%name)))
     do i=1,size(targets)
 
         exe_target => targets(i)%ptr
@@ -516,11 +536,12 @@ subroutine cmd_run(settings,test)
 
                     do j=1,size(settings%name)
 
-                        if (glob(trim(exe_source%exe_name),trim(settings%name(j)))) then
+                        if (glob(trim(exe_source%exe_name),trim(settings%name(j))) .and. .not.found(j)) then
+
 
                             found(j) = .true.
                             exe_cmd%s = exe_target%output_file
-                            executables = [executables, exe_cmd]
+                            executables(j) = exe_cmd
 
                         end if
 
@@ -543,6 +564,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
@@ -587,10 +610,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
@@ -677,27 +700,37 @@ subroutine delete_skip(is_unix)
     end do
 end subroutine delete_skip
 
+!> Delete the build directory including or excluding dependencies. Can be used
+!> to clear the registry cache.
 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
+    type(fpm_global_settings) :: global_settings
+    type(error_t), allocatable :: error
+
+    ! Clear registry cache
+    if (settings%registry_cache) then
+        call get_global_settings(global_settings, error) 
+        if (allocated(error)) return
+
+        call os_delete_dir(os_is_unix(), global_settings%registry_settings%cache_path)
+    end if
+
     if (is_dir('build')) then
-        ! remove the entire build directory
-        if (settings%clean_call) then
-            call os_delete_dir(settings%is_unix, 'build')
-            return
+        ! Remove the entire build directory
+        if (settings%clean_all) then
+            call os_delete_dir(os_is_unix(), 'build'); return
+        ! Remove the build directory but skip dependencies
+        else if (settings%clean_skip) then
+            call delete_skip(os_is_unix()); return
         end if
-        ! remove the build directory but skip dependencies
-        if (settings%clean_skip) then
-            call delete_skip(settings%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
new file mode 100644
index 0000000000..d2ec0dbaf1
--- /dev/null
+++ b/src/fpm/cmd/export.f90
@@ -0,0 +1,83 @@
+module fpm_cmd_export
+  use fpm_command_line, only : fpm_export_settings
+  use fpm_dependency, only : dependency_tree_t, new_dependency_tree
+  use fpm_error, only : error_t, fpm_stop
+  use fpm_filesystem, only : join_path
+  use fpm_manifest, only : package_config_t, get_package_data
+  use fpm_toml, only: name_is_json
+  use fpm_model, only: fpm_model_t
+  use fpm, only: build_model
+  implicit none
+  private
+  public :: cmd_export
+
+contains
+
+  !> Entry point for the export subcommand
+  subroutine cmd_export(settings)
+    !> Representation of the command line arguments
+    type(fpm_export_settings), intent(inout) :: settings
+    type(package_config_t) :: package
+    type(dependency_tree_t) :: deps
+    type(fpm_model_t) :: model
+    type(error_t), allocatable :: error
+
+    integer :: ii
+    character(len=:), allocatable :: filename
+
+    if (len_trim(settings%dump_manifest)<=0 .and. &
+        len_trim(settings%dump_model)<=0 .and. &
+        len_trim(settings%dump_dependencies)<=0) then
+        call fpm_stop(0,'*cmd_export* exiting: no manifest/model/dependencies keyword provided')
+    end if
+
+    !> Read in manifest
+    call get_package_data(package, "fpm.toml", error, apply_defaults=.true.)
+    call handle_error(error)
+
+    !> Export manifest
+    if (len_trim(settings%dump_manifest)>0) then
+       filename = trim(settings%dump_manifest)
+       call package%dump(filename, error, json=name_is_json(filename))
+    end if
+
+    !> Export dependency tree
+    if (len_trim(settings%dump_dependencies)>0) then
+
+        !> Generate dependency tree
+        filename = join_path("build", "cache.toml")
+        call new_dependency_tree(deps, cache=filename, verbosity=merge(2, 1, settings%verbose))
+        call deps%add(package, error)
+        call handle_error(error)
+
+        !> Export dependency tree
+        filename = settings%dump_dependencies
+        call deps%dump(filename, error, json=name_is_json(filename))
+        call handle_error(error)
+    end if
+
+    !> Export full model
+    if (len_trim(settings%dump_model)>0) then
+
+        call build_model(model, settings%fpm_build_settings, package, error)
+        if (allocated(error)) then
+            call fpm_stop(1,'*cmd_export* Model error: '//error%message)
+        end if
+
+        filename = settings%dump_model
+        call model%dump(filename, error, json=name_is_json(filename))
+        call handle_error(error)
+    end if
+
+  end subroutine cmd_export
+
+  !> Error handling for this command
+  subroutine handle_error(error)
+    !> Potential error
+    type(error_t), intent(in), optional :: error
+    if (present(error)) then
+      call fpm_stop(1, '*cmd_export* error: '//error%message)
+    end if
+  end subroutine handle_error
+
+end module fpm_cmd_export
diff --git a/src/fpm/cmd/publish.f90 b/src/fpm/cmd/publish.f90
index 43636c0e30..225e83f923 100644
--- a/src/fpm/cmd/publish.f90
+++ b/src/fpm/cmd/publish.f90
@@ -65,8 +65,10 @@ subroutine cmd_publish(settings)
     end do
 
     tmp_file = get_temp_filename()
-    call git_archive('.', tmp_file, 'HEAD', settings%verbose, error)
+    call git_archive('.', tmp_file, 'HEAD', additional_files=['fpm_model.json'], verbose=settings%verbose, error=error)
     if (allocated(error)) call fpm_stop(1, '*cmd_publish* Archive error: '//error%message)
+    call model%dump('fpm_model.json', error, json=.true.)
+    if (allocated(error)) call fpm_stop(1, '*cmd_publish* Model dump error: '//error%message)
 
     upload_data = [ &
     & string_t('package_name="'//package%name//'"'), &
diff --git a/src/fpm/cmd/update.f90 b/src/fpm/cmd/update.f90
index 09f1450c1b..a78473b3a9 100644
--- a/src/fpm/cmd/update.f90
+++ b/src/fpm/cmd/update.f90
@@ -4,6 +4,7 @@ module fpm_cmd_update
   use fpm_error, only : error_t, fpm_stop
   use fpm_filesystem, only : exists, mkdir, join_path, delete_file, filewrite
   use fpm_manifest, only : package_config_t, get_package_data
+  use fpm_toml, only: name_is_json
   implicit none
   private
   public :: cmd_update
@@ -14,10 +15,10 @@ module fpm_cmd_update
   subroutine cmd_update(settings)
     !> Representation of the command line arguments
     type(fpm_update_settings), intent(in) :: settings
+
     type(package_config_t) :: package
     type(dependency_tree_t) :: deps
     type(error_t), allocatable :: error
-
     integer :: ii
     character(len=:), allocatable :: cache
 
@@ -57,6 +58,11 @@ subroutine cmd_update(settings)
       end do
     end if
 
+    if (len_trim(settings%dump)>0) then
+        call deps%dump(trim(settings%dump), error, json=name_is_json(trim(settings%dump)))
+        call handle_error(error)
+    end if
+
   end subroutine cmd_update
 
   !> Error handling for this command
@@ -64,7 +70,7 @@ subroutine handle_error(error)
     !> Potential error
     type(error_t), intent(in), optional :: error
     if (present(error)) then
-      call fpm_stop(1, error%message)
+      call fpm_stop(1, '*cmd_update* error: '//error%message)
     end if
   end subroutine handle_error
 
diff --git a/src/fpm/dependency.f90 b/src/fpm/dependency.f90
index 53e113a585..19d7c32648 100644
--- a/src/fpm/dependency.f90
+++ b/src/fpm/dependency.f90
@@ -60,12 +60,13 @@ module fpm_dependency
   use fpm_error, only: error_t, fatal_error
   use fpm_filesystem, only: exists, join_path, mkdir, canon_path, windows_path, list_files, is_dir, basename, &
                             os_delete_dir, get_temp_filename, parent_dir
-  use fpm_git, only: git_target_revision, git_target_default, git_revision, operator(==)
+  use fpm_git, only: git_target_revision, git_target_default, git_revision, operator(==), serializable_t
   use fpm_manifest, only: package_config_t, dependency_config_t, get_package_data
-  use fpm_manifest_dependency, only: manifest_has_changed
+  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
+                      get_value, set_value, add_table, toml_load, toml_stat, set_string
   use fpm_versioning, only: version_t, new_version
   use fpm_settings, only: fpm_global_settings, get_global_settings, official_registry_base_url
   use fpm_downloader, only: downloader_t
@@ -75,7 +76,7 @@ module fpm_dependency
   private
 
   public :: dependency_tree_t, new_dependency_tree, dependency_node_t, new_dependency_node, resize, &
-            & check_and_read_pkg_data
+            & check_and_read_pkg_data, destroy_dependency_node
 
   !> Overloaded reallocation interface
   interface resize
@@ -104,13 +105,19 @@ module fpm_dependency
     procedure, private :: get_from_local_registry
     !> Print information on this instance
     procedure :: info
+
+    !> Serialization interface
+    procedure :: serializable_is_same => dependency_node_is_same
+    procedure :: dump_to_toml => node_dump_to_toml
+    procedure :: load_from_toml => node_load_from_toml
+
   end type dependency_node_t
 
   !> Respresentation of a projects dependencies
   !>
   !> The dependencies are stored in a simple array for now, this can be replaced
   !> with a binary-search tree or a hash table in the future.
-  type :: dependency_tree_t
+  type, extends(serializable_t) :: dependency_tree_t
     !> Unit for IO
     integer :: unit = output_unit
     !> Verbosity of printout
@@ -158,27 +165,33 @@ module fpm_dependency
     !> Depedendncy resolution finished
     procedure :: finished
     !> Reading of dependency tree
-    generic :: load => load_from_file, load_from_unit, load_from_toml
+    generic :: load_cache => load_cache_from_file, load_cache_from_unit, load_cache_from_toml
     !> Read dependency tree from file
-    procedure, private :: load_from_file
+    procedure, private :: load_cache_from_file
     !> Read dependency tree from formatted unit
-    procedure, private :: load_from_unit
+    procedure, private :: load_cache_from_unit
     !> Read dependency tree from TOML data structure
-    procedure, private :: load_from_toml
+    procedure, private :: load_cache_from_toml
     !> Writing of dependency tree
-    generic :: dump => dump_to_file, dump_to_unit, dump_to_toml
+    generic :: dump_cache => dump_cache_to_file, dump_cache_to_unit, dump_cache_to_toml
     !> Write dependency tree to file
-    procedure, private :: dump_to_file
+    procedure, private :: dump_cache_to_file
     !> Write dependency tree to formatted unit
-    procedure, private :: dump_to_unit
+    procedure, private :: dump_cache_to_unit
     !> Write dependency tree to TOML data structure
-    procedure, private :: dump_to_toml
+    procedure, private :: dump_cache_to_toml
     !> Update dependency tree
     generic :: update => update_dependency, update_tree
     !> Update a list of dependencies
     procedure, private :: update_dependency
     !> Update all dependencies in the tree
     procedure, private :: update_tree
+
+    !> Serialization interface
+    procedure :: serializable_is_same => dependency_tree_is_same
+    procedure :: dump_to_toml   => tree_dump_to_toml
+    procedure :: load_from_toml => tree_load_from_toml
+
   end type dependency_tree_t
 
   !> Common output format for writing to the command line
@@ -315,8 +328,8 @@ subroutine add_project(self, package, error)
 
     ! After resolving all dependencies, check if we have cached ones to avoid updates
     if (allocated(self%cache)) then
-      call new_dependency_tree(cached, verbosity=self%verbosity, cache=self%cache)
-      call cached%load(self%cache, error)
+      call new_dependency_tree(cached, verbosity=self%verbosity,cache=self%cache)
+      call cached%load_cache(self%cache, error)
       if (allocated(error)) return
 
       ! Skip root node
@@ -335,7 +348,7 @@ subroutine add_project(self, package, error)
     if (allocated(error)) return
 
     if (allocated(self%cache)) then
-      call self%dump(self%cache, error)
+      call self%dump_cache(self%cache, error)
       if (allocated(error)) return
     end if
 
@@ -398,6 +411,9 @@ recursive subroutine add_project_dependencies(self, package, root, main, error)
       end if
     end if
 
+    !> Ensure allocation fits
+    call resize(self%dep,self%ndep)
+
   end subroutine add_project_dependencies
 
   !> Add a list of dependencies to the dependency tree
@@ -422,6 +438,9 @@ subroutine add_dependencies(self, dependency, error)
     end do
     if (allocated(error)) return
 
+    !> Ensure allocation fits ndep
+    call resize(self%dep,self%ndep)
+
   end subroutine add_dependencies
 
   !> Add a single dependency node to the dependency tree
@@ -456,6 +475,10 @@ subroutine add_dependency_node(self, dependency, error)
         end if
       end if
     else
+
+      !> Safety: reallocate if necessary
+      if (size(self%dep)==self%ndep) call resize(self%dep,self%ndep+1)
+
       ! New dependency: add from scratch
       self%ndep = self%ndep + 1
       self%dep(self%ndep) = dependency
@@ -694,7 +717,7 @@ subroutine get_from_registry(self, target_dir, global_settings, error, downloade
     end if
 
     ! Include namespace and package name in the target url and download package data.
-    target_url = global_settings%registry_settings%url//'/packages/'//self%namespace//'/'//self%name
+    target_url = global_settings%registry_settings%url//'packages/'//self%namespace//'/'//self%name
     call downloader%get_pkg_data(target_url, self%requested_version, tmp_file, json, error)
     close (unit, status='delete')
     if (allocated(error)) return
@@ -982,7 +1005,7 @@ subroutine register(self, package, root, fetch, revision, error)
   end subroutine register
 
   !> Read dependency tree from file
-  subroutine load_from_file(self, file, error)
+  subroutine load_cache_from_file(self, file, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> File name
@@ -997,12 +1020,12 @@ subroutine load_from_file(self, file, error)
     if (.not. exist) return
 
     open (file=file, newunit=unit)
-    call self%load(unit, error)
+    call self%load_cache(unit, error)
     close (unit)
-  end subroutine load_from_file
+  end subroutine load_cache_from_file
 
   !> Read dependency tree from file
-  subroutine load_from_unit(self, unit, error)
+  subroutine load_cache_from_unit(self, unit, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> File name
@@ -1021,13 +1044,13 @@ subroutine load_from_unit(self, unit, error)
       return
     end if
 
-    call self%load(table, error)
+    call self%load_cache(table, error)
     if (allocated(error)) return
 
-  end subroutine load_from_unit
+  end subroutine load_cache_from_unit
 
   !> Read dependency tree from TOML data structure
-  subroutine load_from_toml(self, table, error)
+  subroutine load_cache_from_toml(self, table, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> Data structure
@@ -1089,10 +1112,10 @@ subroutine load_from_toml(self, table, error)
     if (allocated(error)) return
 
     self%ndep = size(list)
-  end subroutine load_from_toml
+  end subroutine load_cache_from_toml
 
   !> Write dependency tree to file
-  subroutine dump_to_file(self, file, error)
+  subroutine dump_cache_to_file(self, file, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> File name
@@ -1103,14 +1126,14 @@ subroutine dump_to_file(self, file, error)
     integer :: unit
 
     open (file=file, newunit=unit)
-    call self%dump(unit, error)
+    call self%dump_cache(unit, error)
     close (unit)
     if (allocated(error)) return
 
-  end subroutine dump_to_file
+  end subroutine dump_cache_to_file
 
   !> Write dependency tree to file
-  subroutine dump_to_unit(self, unit, error)
+  subroutine dump_cache_to_unit(self, unit, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> Formatted unit
@@ -1121,14 +1144,14 @@ subroutine dump_to_unit(self, unit, error)
     type(toml_table) :: table
 
     table = toml_table()
-    call self%dump(table, error)
+    call self%dump_cache(table, error)
 
     write (unit, '(a)') toml_serialize(table)
 
-  end subroutine dump_to_unit
+  end subroutine dump_cache_to_unit
 
   !> Write dependency tree to TOML datastructure
-  subroutine dump_to_toml(self, table, error)
+  subroutine dump_cache_to_toml(self, table, error)
     !> Instance of the dependency tree
     class(dependency_tree_t), intent(inout) :: self
     !> Data structure
@@ -1165,7 +1188,7 @@ subroutine dump_to_toml(self, table, error)
     end do
     if (allocated(error)) return
 
-  end subroutine dump_to_toml
+  end subroutine dump_cache_to_toml
 
   !> Reallocate a list of dependencies
   pure subroutine resize_dependency_node(var, n)
@@ -1209,6 +1232,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
@@ -1241,10 +1266,313 @@ logical function dependency_has_changed(cached, manifest, verbosity, iunit) resu
     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) "PREPROCESS has changed presence "
+      return
+    end if
 
     !> All checks passed: the two dependencies have no differences
     has_changed = .false.
 
   end function dependency_has_changed
 
+  !> Check that two dependency nodes are equal
+  logical function dependency_node_is_same(this,that)
+      class(dependency_node_t), intent(in) :: this
+      class(serializable_t), intent(in) :: that
+
+      dependency_node_is_same = .false.
+
+      select type (other=>that)
+         type is (dependency_node_t)
+
+            ! Base class must match
+            if (.not.(this%dependency_config_t==other%dependency_config_t)) return
+
+            ! Extension must match
+            if (.not.(this%done  .eqv.other%done)) return
+            if (.not.(this%update.eqv.other%update)) return
+            if (.not.(this%cached.eqv.other%cached)) return
+            if (.not.(this%proj_dir==other%proj_dir)) return
+            if (.not.(this%revision==other%revision)) return
+
+            if (.not.(allocated(this%version).eqv.allocated(other%version))) return
+               if (allocated(this%version)) then
+              if (.not.(this%version==other%version)) return
+            endif
+
+         class default
+            ! Not the same type
+            return
+      end select
+
+      !> All checks passed!
+      dependency_node_is_same = .true.
+
+  end function dependency_node_is_same
+
+    !> Dump dependency to toml table
+    subroutine node_dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_node_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: ierr
+
+        ! Dump parent class
+        call self%dependency_config_t%dump_to_toml(table, error)
+        if (allocated(error)) return
+
+        if (allocated(self%version)) then
+            call set_string(table, "version", self%version%s(), error,'dependency_node_t')
+            if (allocated(error)) return
+        endif
+        call set_string(table, "proj-dir", self%proj_dir, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call set_string(table, "revision", self%revision, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call set_value(table, "done", self%done, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call set_value(table, "update", self%update, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call set_value(table, "cached", self%cached, error, 'dependency_node_t')
+        if (allocated(error)) return
+
+    end subroutine node_dump_to_toml
+
+    !> Read dependency from toml table (no checks made at this stage)
+    subroutine node_load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_node_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        character(len=:), allocatable :: version
+        integer :: ierr
+
+        call destroy_dependency_node(self)
+
+        ! Load parent class
+        call self%dependency_config_t%load_from_toml(table, error)
+        if (allocated(error)) return
+
+        call get_value(table, "done", self%done, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call get_value(table, "update", self%update, error, 'dependency_node_t')
+        if (allocated(error)) return
+        call get_value(table, "cached", self%cached, error, 'dependency_node_t')
+        if (allocated(error)) return
+
+        call get_value(table, "proj-dir", self%proj_dir)
+        call get_value(table, "revision", self%revision)
+
+        call get_value(table, "version", version)
+        if (allocated(version)) then
+            allocate(self%version)
+            call new_version(self%version, version, error)
+            if (allocated(error)) then
+                error%message = 'dependency_node_t: version error from TOML table - '//error%message
+                return
+            endif
+        end if
+
+    end subroutine node_load_from_toml
+
+    !> Destructor
+    elemental subroutine destroy_dependency_node(self)
+
+        class(dependency_node_t), intent(inout) :: self
+
+        integer :: ierr
+
+        call dependency_destroy(self)
+
+        deallocate(self%version,stat=ierr)
+        deallocate(self%proj_dir,stat=ierr)
+        deallocate(self%revision,stat=ierr)
+        self%done = .false.
+        self%update = .false.
+        self%cached = .false.
+
+    end subroutine destroy_dependency_node
+
+  !> Check that two dependency trees are equal
+  logical function dependency_tree_is_same(this,that)
+    class(dependency_tree_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    integer :: ii
+
+    dependency_tree_is_same = .false.
+
+    select type (other=>that)
+       type is (dependency_tree_t)
+
+          if (.not.(this%unit==other%unit)) return
+          if (.not.(this%verbosity==other%verbosity)) return
+          if (.not.(this%dep_dir==other%dep_dir)) return
+          if (.not.(this%ndep==other%ndep)) return
+          if (.not.(allocated(this%dep).eqv.allocated(other%dep))) return
+          if (allocated(this%dep)) then
+             if (.not.(size(this%dep)==size(other%dep))) return
+             do ii = 1, size(this%dep)
+                if (.not.(this%dep(ii)==other%dep(ii))) return
+             end do
+          endif
+          if (.not.(this%cache==other%cache)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    dependency_tree_is_same = .true.
+
+  end function dependency_tree_is_same
+
+    !> Dump dependency to toml table
+    subroutine tree_dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_tree_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: ierr, ii
+        type(toml_table), pointer :: ptr_deps,ptr
+        character(27) :: unnamed
+
+        call set_value(table, "unit", self%unit, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call set_value(table, "verbosity", self%verbosity, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call set_string(table, "dep-dir", self%dep_dir, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call set_string(table, "cache", self%cache, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call set_value(table, "ndep", self%ndep, error, 'dependency_tree_t')
+        if (allocated(error)) return
+
+        if (allocated(self%dep)) then
+
+           ! Create dependency table
+           call add_table(table, "dependencies", ptr_deps)
+           if (.not. associated(ptr_deps)) then
+              call fatal_error(error, "dependency_tree_t cannot create dependency table ")
+              return
+           end if
+
+           do ii = 1, size(self%dep)
+              associate (dep => self%dep(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(dep%name)==0) then
+                    write(unnamed,1) ii
+                    call add_table(ptr_deps, trim(unnamed), ptr)
+                 else
+                    call add_table(ptr_deps, dep%name, ptr)
+                 end if
+                 if (.not. associated(ptr)) then
+                    call fatal_error(error, "dependency_tree_t cannot create entry for dependency "//dep%name)
+                    return
+                 end if
+                 call dep%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+              end associate
+           end do
+
+        endif
+
+        1 format('UNNAMED_DEPENDENCY_',i0)
+
+    end subroutine tree_dump_to_toml
+
+    !> Read dependency from toml table (no checks made at this stage)
+    subroutine tree_load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_tree_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        type(toml_key), allocatable :: keys(:),dep_keys(:)
+        type(toml_table), pointer :: ptr_deps,ptr
+        integer :: ii, jj, ierr
+
+        call table%get_keys(keys)
+
+        call get_value(table, "unit", self%unit, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call get_value(table, "verbosity", self%verbosity, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call get_value(table, "ndep", self%ndep, error, 'dependency_tree_t')
+        if (allocated(error)) return
+        call get_value(table, "dep-dir", self%dep_dir)
+        call get_value(table, "cache", self%cache)
+
+        find_deps_table: do ii = 1, size(keys)
+            if (keys(ii)%key=="dependencies") then
+
+               call get_value(table, keys(ii), ptr_deps)
+               if (.not.associated(ptr_deps)) then
+                  call fatal_error(error,'dependency_tree_t: error retrieving dependency table from TOML table')
+                  return
+               end if
+
+               !> Read all dependencies
+               call ptr_deps%get_keys(dep_keys)
+               call resize(self%dep, size(dep_keys))
+
+               do jj = 1, size(dep_keys)
+
+                   call get_value(ptr_deps, dep_keys(jj), ptr)
+                   call self%dep(jj)%load_from_toml(ptr, error)
+                   if (allocated(error)) return
+
+               end do
+
+               exit find_deps_table
+
+            endif
+        end do find_deps_table
+
+    end subroutine tree_load_from_toml
+
+
 end module fpm_dependency
diff --git a/src/fpm/fpm_release.F90 b/src/fpm/fpm_release.F90
index e80050b3ee..1a09437385 100644
--- a/src/fpm/fpm_release.F90
+++ b/src/fpm/fpm_release.F90
@@ -18,7 +18,7 @@ type(version_t) function fpm_version()
 
 ! Fallback to last known version in case of undefined macro
 #ifndef FPM_RELEASE_VERSION
-#  define FPM_RELEASE_VERSION 0.8.0
+#  define FPM_RELEASE_VERSION 0.10.1
 #endif
 
 ! Accept solution from https://stackoverflow.com/questions/31649691/stringify-macro-with-gnu-gfortran
diff --git a/src/fpm/git.f90 b/src/fpm/git.f90
index c007743a90..1f2891af8a 100644
--- a/src/fpm/git.f90
+++ b/src/fpm/git.f90
@@ -2,7 +2,7 @@
 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, 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, &
@@ -26,6 +26,9 @@ module fpm_git
         !> Commit hash
         integer :: revision = 203
 
+        !> Invalid descriptor
+        integer :: error = -999
+
     end type enum_descriptor
 
     !> Actual enumerator for descriptors
@@ -33,7 +36,7 @@ module fpm_git
 
 
     !> Description of an git target
-    type :: git_target_t
+    type, extends(serializable_t) :: git_target_t
 
         !> Kind of the git target
         integer :: descriptor = git_descriptor%default
@@ -52,12 +55,12 @@ module fpm_git
         !> Show information on instance
         procedure :: info
 
-    end type git_target_t
+        !> Serialization interface
+        procedure :: serializable_is_same => git_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
 
-
-    interface operator(==)
-        module procedure git_target_eq
-    end interface
+    end type git_target_t
 
     !> Common output format for writing to the command line
     character(len=*), parameter :: out_fmt = '("#", *(1x, g0))'
@@ -137,16 +140,28 @@ function git_target_tag(url, tag) result(self)
     end function git_target_tag
 
     !> Check that two git targets are equal
-    logical function git_target_eq(this,that) result(is_equal)
+    logical function git_is_same(this,that)
+        class(git_target_t), intent(in) :: this
+        class(serializable_t), intent(in) :: that
 
-        !> Two input git targets
-        type(git_target_t), intent(in) :: this,that
+        git_is_same = .false.
+
+        select type (other=>that)
+           type is (git_target_t)
+
+              if (.not.(this%descriptor==other%descriptor)) return
+              if (.not.(this%url==other%url)) return
+              if (.not.(this%object==other%object)) return
 
-        is_equal = this%descriptor == that%descriptor .and. &
-                   this%url        == that%url        .and. &
-                   this%object     == that%object
+           class default
+              ! Not the same type
+              return
+        end select
 
-    end function git_target_eq
+        !> All checks passed!
+        git_is_same = .true.
+
+    end function git_is_same
 
     !> Check that a cached dependency matches a manifest request
     logical function git_matches_manifest(cached,manifest,verbosity,iunit)
@@ -308,21 +323,106 @@ subroutine info(self, unit, verbosity)
 
     end subroutine info
 
+    !> Dump dependency to toml table
+    subroutine dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(git_target_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: ierr
+
+        call set_string(table, "descriptor", descriptor_name(self%descriptor), error, 'git_target_t')
+        if (allocated(error)) return
+        call set_string(table, "url", self%url, error, 'git_target_t')
+        if (allocated(error)) return
+        call set_string(table, "object", self%object, error, 'git_target_t')
+        if (allocated(error)) return
+
+    end subroutine dump_to_toml
+
+    !> Read dependency from toml table (no checks made at this stage)
+    subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(git_target_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        character(len=:), allocatable :: descriptor_name
+
+        call get_value(table, "descriptor", descriptor_name)
+        self%descriptor = parse_descriptor(descriptor_name)
+
+        if (self%descriptor==git_descriptor%error) then
+            call fatal_error(error,"invalid descriptor ID <"//descriptor_name//"> in TOML entry")
+            return
+        end if
+
+        !> Target URL of the git repository
+        call get_value(table, "url", self%url)
+
+        !> Additional descriptor of the git object
+        call get_value(table,"object", self%object)
+
+    end subroutine load_from_toml
+
+    !> Parse git descriptor identifier from a string
+    pure integer function parse_descriptor(name)
+        character(len=*), intent(in) :: name
+
+        select case (name)
+           case ("default");  parse_descriptor = git_descriptor%default
+           case ("branch");   parse_descriptor = git_descriptor%branch
+           case ("tag");      parse_descriptor = git_descriptor%tag
+           case ("revision"); parse_descriptor = git_descriptor%revision
+           case default;      parse_descriptor = git_descriptor%error
+        end select
+
+    end function parse_descriptor
+
+    !> Code git descriptor to a string
+    pure function descriptor_name(descriptor) result(name)
+       integer, intent(in) :: descriptor
+       character(len=:), allocatable :: name
+
+       select case (descriptor)
+          case (git_descriptor%default);   name = "default"
+          case (git_descriptor%branch);    name = "branch"
+          case (git_descriptor%tag);       name = "tag"
+          case (git_descriptor%revision);  name = "revision"
+          case default;                    name = "ERROR"
+       end select
+
+    end function descriptor_name
+
   !> Archive a folder using `git archive`.
-  subroutine git_archive(source, destination, ref, verbose, error)
+  subroutine git_archive(source, destination, ref, additional_files, 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
+    !> (Optional) list of additional untracked files to be added to the archive.
+    character(*), optional, intent(in) :: additional_files(:)
     !> 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
+    integer :: stat,i
+    character(len=:), allocatable :: cmd_output, archive_format, add_files
 
     call execute_and_read_output('git archive -l', cmd_output, error, verbose)
     if (allocated(error)) return
@@ -333,7 +433,19 @@ subroutine git_archive(source, destination, ref, verbose, error)
       call fatal_error(error, "Cannot find a suitable archive format for 'git archive'."); return
     end if
 
-    call run('git archive '//ref//' --format='//archive_format//' -o '//destination, echo=verbose, exitstat=stat)
+    allocate(character(len=0) :: add_files)
+    if (present(additional_files)) then 
+       do i=1,size(additional_files)
+          add_files = trim(add_files)//' --add-file='//adjustl(additional_files(i))
+       end do
+    endif
+
+    call run('git archive '//ref//' &
+        --format='//archive_format// &
+        add_files//' \
+        -o '//destination, \
+        echo=verbose, \
+        exitstat=stat)
     if (stat /= 0) then
       call fatal_error(error, "Error packing '"//source//"'."); return
     end if
diff --git a/src/fpm/manifest/build.f90 b/src/fpm/manifest/build.f90
index 537fd3dd3a..035ea0d51d 100644
--- a/src/fpm/manifest/build.f90
+++ b/src/fpm/manifest/build.f90
@@ -11,24 +11,25 @@
 !>```
 module fpm_manifest_build
     use fpm_error, only : error_t, syntax_error, fatal_error
-    use fpm_strings, only : string_t, len_trim, is_valid_module_prefix
-    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list
+    use fpm_strings, only : string_t, len_trim, is_valid_module_prefix, operator(==)
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list, serializable_t, &
+                         set_value, set_string, set_list
     implicit none
     private
 
     public :: build_config_t, new_build_config
 
     !> Configuration data for build
-    type :: build_config_t
+    type, extends(serializable_t) :: build_config_t
 
         !> Automatic discovery of executables
-        logical :: auto_executables
+        logical :: auto_executables = .true.
 
         !> Automatic discovery of examples
-        logical :: auto_examples
+        logical :: auto_examples = .true.
 
         !> Automatic discovery of tests
-        logical :: auto_tests
+        logical :: auto_tests = .true.
 
         !> Enforcing of package module names
         logical :: module_naming = .false.
@@ -45,8 +46,15 @@ module fpm_manifest_build
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => build_conf_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
+
     end type build_config_t
 
+    character(*), parameter, private :: class_name = 'build_config_t'
+
 
 contains
 
@@ -97,9 +105,8 @@ subroutine new_build_config(self, table, package_name, error)
 
         if (stat == toml_stat%success) then
 
-            ! Boolean value found. Set no custom prefix. This also falls back to
-            ! key not provided
-            self%module_prefix = string_t("")
+            ! Boolean value found. Set no custom prefix. This also falls back to key not provided
+            if (allocated(self%module_prefix%s)) deallocate(self%module_prefix%s)
 
         else
 
@@ -211,4 +218,110 @@ subroutine info(self, unit, verbosity)
 
     end subroutine info
 
+    !> Check that two dependency trees are equal
+    logical function build_conf_is_same(this,that)
+      class(build_config_t), intent(in) :: this
+      class(serializable_t), intent(in) :: that
+
+      build_conf_is_same = .false.
+
+      select type (other=>that)
+         type is (build_config_t)
+
+             if (this%auto_executables.neqv.other%auto_executables) return
+             if (this%auto_examples.neqv.other%auto_examples) return
+             if (this%auto_tests.neqv.other%auto_tests) return
+             if (this%module_naming.neqv.other%module_naming) return
+             if (.not.this%module_prefix==other%module_prefix) return
+             if (.not.this%link==other%link) return
+             if (.not.this%external_modules==other%external_modules) return
+
+         class default
+            ! Not the same type
+            return
+      end select
+
+      !> All checks passed!
+      build_conf_is_same = .true.
+
+    end function build_conf_is_same
+
+    !> Dump build config to toml table
+    subroutine dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(build_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        call set_value(table, "auto-executables", self%auto_executables, error, class_name)
+        if (allocated(error)) return
+        call set_value(table, "auto-tests", self%auto_tests, error, class_name)
+        if (allocated(error)) return
+        call set_value(table, "auto-examples", self%auto_examples, error, class_name)
+        if (allocated(error)) return
+
+        ! Module naming can either contain a boolean value, or the prefix
+        has_prefix: if (self%module_naming .and. len_trim(self%module_prefix)>0) then
+            call set_string(table, "module-naming", self%module_prefix, error, class_name)
+        else
+            call set_value (table, "module-naming", self%module_naming, error, class_name)
+        end if has_prefix
+        if (allocated(error)) return
+
+        call set_list(table, "link", self%link, error)
+        if (allocated(error)) return
+        call set_list(table, "external-modules", self%external_modules, error)
+        if (allocated(error)) return
+
+    end subroutine dump_to_toml
+
+    !> Read build config from toml table (no checks made at this stage)
+    subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(build_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: stat
+
+        call get_value(table, "auto-executables", self%auto_executables, error, class_name)
+        if (allocated(error)) return
+        call get_value(table, "auto-tests", self%auto_tests, error, class_name)
+        if (allocated(error)) return
+        call get_value(table, "auto-examples", self%auto_examples, error, class_name)
+        if (allocated(error)) return
+
+        !> Module naming: fist, attempt boolean value first
+        call get_value(table, "module-naming", self%module_naming, .false., stat=stat)
+        if (stat == toml_stat%success) then
+            ! Boolean value found. Set no custom prefix. This also falls back to key not provided
+            if (allocated(self%module_prefix%s)) deallocate(self%module_prefix%s)
+        else
+            !> Value found, but not a boolean. Attempt to read a prefix string
+            call get_value(table, "module-naming", self%module_prefix%s)
+            if (.not.allocated(self%module_prefix%s)) then
+               call syntax_error(error,"Could not read value for 'module-naming' in fpm.toml, expecting logical or a string")
+               return
+            end if
+            self%module_naming = .true.
+        end if
+
+        call get_list(table, "link", self%link, error)
+        if (allocated(error)) return
+        call get_list(table, "external-modules", self%external_modules, error)
+        if (allocated(error)) return
+
+    end subroutine load_from_toml
+
+
 end module fpm_manifest_build
diff --git a/src/fpm/manifest/dependency.f90 b/src/fpm/manifest/dependency.f90
index 75f5f5d10d..10fd791297 100644
--- a/src/fpm/manifest/dependency.f90
+++ b/src/fpm/manifest/dependency.f90
@@ -23,22 +23,26 @@
 !> Resolving a dependency will result in obtaining a new package configuration
 !> data for the respective project.
 module fpm_manifest_dependency
-    use fpm_error, only: error_t, syntax_error
+    use fpm_error, only: error_t, syntax_error, fatal_error
     use fpm_git, only: git_target_t, git_target_tag, git_target_branch, &
-        & git_target_revision, git_target_default, operator(==), git_matches_manifest
-    use fpm_toml, only: toml_table, toml_key, toml_stat, get_value, check_keys
+        & git_target_revision, git_target_default, 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, 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
 
-    public :: dependency_config_t, new_dependency, new_dependencies, manifest_has_changed
+    public :: dependency_config_t, new_dependency, new_dependencies, manifest_has_changed, &
+        & dependency_destroy, resize
 
     !> Configuration meta data for a dependency
-    type :: dependency_config_t
+    type, extends(serializable_t) :: dependency_config_t
 
         !> Name of the dependency
         character(len=:), allocatable :: name
@@ -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
 
@@ -63,11 +70,20 @@ module fpm_manifest_dependency
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => dependency_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
+
     end type dependency_config_t
 
     !> Common output format for writing to the command line
     character(len=*), parameter :: out_fmt = '("#", *(1x, g0))'
 
+    interface resize
+        module procedure resize_dependency_config
+    end interface resize
+
 contains
 
     !> Construct a new dependency configuration from a TOML data structure
@@ -87,12 +103,28 @@ 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)
@@ -128,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
@@ -149,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) :: &
@@ -158,7 +183,8 @@ subroutine check(table, error)
               "git", &
               "tag", &
               "branch", &
-              "rev" &
+              "rev", &
+              "preprocess" &
             & ]
 
         call table%get_key(name)
@@ -202,6 +228,18 @@ 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
@@ -350,5 +388,169 @@ logical function manifest_has_changed(cached, manifest, verbosity, iunit) result
 
     end function manifest_has_changed
 
+    !> Clean memory
+    elemental subroutine dependency_destroy(self)
+        class(dependency_config_t), intent(inout) :: self
+
+        if (allocated(self%name)) deallocate(self%name)
+        if (allocated(self%path)) deallocate(self%path)
+        if (allocated(self%namespace)) deallocate(self%namespace)
+        if (allocated(self%requested_version)) deallocate(self%requested_version)
+        if (allocated(self%git)) deallocate(self%git)
+
+    end subroutine dependency_destroy
+
+    !> Check that two dependency configs are equal
+    logical function dependency_is_same(this,that)
+        class(dependency_config_t), intent(in) :: this
+        class(serializable_t), intent(in) :: that
+
+        dependency_is_same = .false.
+
+        select type (other=>that)
+           type is (dependency_config_t)
+
+              if (.not.(this%name==other%name)) return
+              if (.not.(this%path==other%path)) return
+              if (.not.(this%namespace==other%namespace)) return
+              if (.not.(allocated(this%requested_version).eqv.allocated(other%requested_version))) return
+              if (allocated(this%requested_version)) then
+                if (.not.(this%requested_version==other%requested_version)) return
+              endif
+
+              if (.not.(allocated(this%git).eqv.allocated(other%git))) return
+              if (allocated(this%git)) then
+                if (.not.(this%git==other%git)) return
+              endif
+
+           class default
+              ! Not the same type
+              return
+        end select
+
+        !> All checks passed!
+        dependency_is_same = .true.
+
+    end function dependency_is_same
+
+    !> Dump dependency to toml table
+    subroutine dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(toml_table), pointer :: ptr
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: ierr
+
+        call set_string(table, "name", self%name, error, 'dependency_config_t')
+        if (allocated(error)) return
+        call set_string(table, "path", self%path, error, 'dependency_config_t')
+        if (allocated(error)) return
+        call set_string(table, "namespace", self%namespace, error, 'dependency_config_t')
+        if (allocated(error)) return
+        if (allocated(self%requested_version)) then
+             call set_string(table, "requested_version", self%requested_version%s(), error, 'dependency_config_t')
+             if (allocated(error)) return
+        endif
+
+        if (allocated(self%git)) then
+            call add_table(table, "git", ptr, error)
+            if (allocated(error)) return
+            call self%git%dump_to_toml(ptr, error)
+            if (allocated(error)) return
+        endif
+
+    end subroutine dump_to_toml
+
+    !> Read dependency from toml table (no checks made at this stage)
+    subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(dependency_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        type(toml_key), allocatable :: list(:)
+        type(toml_table), pointer :: ptr
+        character(len=:), allocatable :: requested_version
+        integer :: ierr,ii
+
+        call dependency_destroy(self)
+
+        call get_value(table, "name", self%name)
+        call get_value(table, "path", self%path)
+        call get_value(table, "namespace", self%namespace)
+        call get_value(table, "requested_version", requested_version)
+        if (allocated(requested_version)) then
+            allocate(self%requested_version)
+            call new_version(self%requested_version, requested_version, error)
+            if (allocated(error)) then
+                error%message = 'dependency_config_t: version error from TOML table - '//error%message
+                return
+            endif
+        end if
+
+        call table%get_keys(list)
+        add_git: do ii = 1, size(list)
+            if (list(ii)%key=="git") then
+               call get_value(table, list(ii)%key, ptr, stat=ierr)
+               if (ierr /= toml_stat%success) then
+                   call fatal_error(error,'dependency_config_t: cannot retrieve git from TOML table')
+                   exit
+               endif
+               allocate(self%git)
+               call self%git%load_from_toml(ptr, error)
+               if (allocated(error)) return
+               exit add_git
+            end if
+        end do add_git
+
+    end subroutine load_from_toml
+
+    !> Reallocate a list of dependencies
+    pure subroutine resize_dependency_config(var, n)
+        !> Instance of the array to be resized
+        type(dependency_config_t), allocatable, intent(inout) :: var(:)
+        !> Dimension of the final array size
+        integer, intent(in), optional :: n
+
+        type(dependency_config_t), allocatable :: tmp(:)
+        integer :: this_size, new_size
+        integer, parameter :: initial_size = 16
+
+        if (allocated(var)) then
+          this_size = size(var, 1)
+          call move_alloc(var, tmp)
+        else
+          this_size = initial_size
+        end if
+
+        if (present(n)) then
+          new_size = n
+        else
+          new_size = this_size + this_size/2 + 1
+        end if
+
+        allocate (var(new_size))
+
+        if (allocated(tmp)) then
+          this_size = min(size(tmp, 1), size(var, 1))
+          var(:this_size) = tmp(:this_size)
+          deallocate (tmp)
+        end if
+
+    end subroutine resize_dependency_config
+
 
 end module fpm_manifest_dependency
diff --git a/src/fpm/manifest/executable.f90 b/src/fpm/manifest/executable.f90
index 66bb0f2cb2..47c500a824 100644
--- a/src/fpm/manifest/executable.f90
+++ b/src/fpm/manifest/executable.f90
@@ -11,10 +11,11 @@
 !>[executable.dependencies]
 !>```
 module fpm_manifest_executable
-    use fpm_manifest_dependency, only : dependency_config_t, new_dependencies
-    use fpm_error, only : error_t, syntax_error, bad_name_error
-    use fpm_strings, only : string_t
-    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list
+    use fpm_manifest_dependency, only : dependency_config_t, new_dependencies, resize
+    use fpm_error, only : error_t, syntax_error, bad_name_error, fatal_error
+    use fpm_strings, only : string_t, operator(==)
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list, serializable_t, add_table, &
+                          set_string, set_list
     implicit none
     private
 
@@ -22,7 +23,7 @@ module fpm_manifest_executable
 
 
     !> Configuation meta data for an executable
-    type :: executable_config_t
+    type, extends(serializable_t) :: executable_config_t
 
         !> Name of the resulting executable
         character(len=:), allocatable :: name
@@ -44,8 +45,15 @@ module fpm_manifest_executable
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => exe_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
+
     end type executable_config_t
 
+    character(*), parameter, private :: class_name = 'executable_config_t'
+
 
 contains
 
@@ -186,4 +194,156 @@ subroutine info(self, unit, verbosity)
     end subroutine info
 
 
+    logical function exe_is_same(this,that)
+        class(executable_config_t), intent(in) :: this
+        class(serializable_t), intent(in) :: that
+
+        integer :: ii
+
+        exe_is_same = .false.
+
+        select type (other=>that)
+           type is (executable_config_t)
+              if (.not.this%link==other%link) return
+              if (.not.allocated(this%name).eqv.allocated(other%name)) return
+              if (.not.this%name==other%name) return
+              if (.not.allocated(this%source_dir).eqv.allocated(other%source_dir)) return
+              if (.not.this%source_dir==other%source_dir) return
+              if (.not.allocated(this%main).eqv.allocated(other%main)) return
+              if (.not.this%main==other%main) return
+              if (.not.allocated(this%dependency).eqv.allocated(other%dependency)) return
+              if (allocated(this%dependency)) then
+                 if (.not.(size(this%dependency)==size(other%dependency))) return
+                 do ii = 1, size(this%dependency)
+                    if (.not.(this%dependency(ii)==other%dependency(ii))) return
+                 end do
+              end if
+           class default
+              ! Not the same type
+              return
+        end select
+
+        !> All checks passed!
+        exe_is_same = .true.
+
+    end function exe_is_same
+
+    !> Dump install config to toml table
+    subroutine dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(executable_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        integer :: ierr, ii
+        type(toml_table), pointer :: ptr_deps,ptr
+        character(27) :: unnamed
+
+        call set_string(table, "name", self%name, error)
+        if (allocated(error)) return
+        call set_string(table, "source-dir", self%source_dir, error)
+        if (allocated(error)) return
+        call set_string(table, "main", self%main, error)
+        if (allocated(error)) return
+
+        if (allocated(self%dependency)) then
+
+           ! Create dependency table
+           call add_table(table, "dependencies", ptr_deps)
+           if (.not. associated(ptr_deps)) then
+              call fatal_error(error, class_name//" cannot create dependency table ")
+              return
+           end if
+
+           do ii = 1, size(self%dependency)
+              associate (dep => self%dependency(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(dep%name)==0) then
+                    write(unnamed,1) ii
+                    call add_table(ptr_deps, trim(unnamed), ptr)
+                 else
+                    call add_table(ptr_deps, dep%name, ptr)
+                 end if
+                 if (.not. associated(ptr)) then
+                    call fatal_error(error, class_name//" cannot create entry for dependency "//dep%name)
+                    return
+                 end if
+                 call dep%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+              end associate
+           end do
+
+        endif
+
+        call set_list(table, "link", self%link, error)
+        if (allocated(error)) return
+
+        1 format('UNNAMED_DEPENDENCY_',i0)
+
+    end subroutine dump_to_toml
+
+    !> Read install config from toml table (no checks made at this stage)
+    subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(executable_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        type(toml_key), allocatable :: keys(:),dep_keys(:)
+        type(toml_table), pointer :: ptr_deps,ptr
+        integer :: ii, jj, ierr
+
+        call table%get_keys(keys)
+
+        call get_value(table, "name", self%name)
+        if (allocated(error)) return
+        call get_value(table, "source-dir", self%source_dir)
+        if (allocated(error)) return
+        call get_value(table, "main", self%main)
+        if (allocated(error)) return
+        call get_list(table, "link", self%link, error)
+
+        find_deps_table: do ii = 1, size(keys)
+            if (keys(ii)%key=="dependencies") then
+
+               call get_value(table, keys(ii), ptr_deps)
+               if (.not.associated(ptr_deps)) then
+                  call fatal_error(error,class_name//': error retrieving dependency table from TOML table')
+                  return
+               end if
+
+               !> Read all dependencies
+               call ptr_deps%get_keys(dep_keys)
+               call resize(self%dependency, size(dep_keys))
+
+               do jj = 1, size(dep_keys)
+
+                   call get_value(ptr_deps, dep_keys(jj), ptr)
+                   call self%dependency(jj)%load_from_toml(ptr, error)
+                   if (allocated(error)) return
+
+               end do
+
+               exit find_deps_table
+
+            endif
+        end do find_deps_table
+
+    end subroutine load_from_toml
+
+
 end module fpm_manifest_executable
diff --git a/src/fpm/manifest/fortran.f90 b/src/fpm/manifest/fortran.f90
index bf76fa2e38..083d61fe1e 100644
--- a/src/fpm/manifest/fortran.f90
+++ b/src/fpm/manifest/fortran.f90
@@ -1,25 +1,34 @@
 module fpm_manifest_fortran
     use fpm_error, only : error_t, syntax_error, fatal_error
-    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, serializable_t, set_value, set_string
     implicit none
     private
 
     public :: fortran_config_t, new_fortran_config
 
     !> Configuration data for Fortran
-    type :: fortran_config_t
+    type, extends(serializable_t) :: fortran_config_t
 
         !> Enable default implicit typing
-        logical :: implicit_typing
+        logical :: implicit_typing = .false.
 
         !> Enable implicit external interfaces
-        logical :: implicit_external
+        logical :: implicit_external = .false.
 
         !> Form to use for all Fortran sources
         character(:), allocatable :: source_form
 
+        contains
+
+            !> Serialization interface
+            procedure :: serializable_is_same => fortran_is_same
+            procedure :: dump_to_toml
+            procedure :: load_from_toml
+
     end type fortran_config_t
 
+    character(len=*), parameter, private :: class_name = 'fortran_config_t'
+
 contains
 
     !> Construct a new build configuration from a TOML data structure
@@ -102,4 +111,68 @@ subroutine check(table, error)
 
     end subroutine check
 
+  logical function fortran_is_same(this,that)
+    class(fortran_config_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    fortran_is_same = .false.
+
+    select type (other=>that)
+       type is (fortran_config_t)
+          if (this%implicit_typing.neqv.other%implicit_typing) return
+          if (this%implicit_external.neqv.other%implicit_external) return
+          if (.not.allocated(this%source_form).eqv.allocated(other%source_form)) return
+          if (.not.this%source_form==other%source_form) return
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    fortran_is_same = .true.
+
+  end function fortran_is_same
+
+  !> Dump install config to toml table
+  subroutine dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fortran_config_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call set_value(table, "implicit-typing", self%implicit_typing, error, class_name)
+    if (allocated(error)) return
+    call set_value(table, "implicit-external", self%implicit_external, error, class_name)
+    if (allocated(error)) return
+    call set_string(table, "source-form", self%source_form, error, class_name)
+    if (allocated(error)) return
+
+  end subroutine dump_to_toml
+
+  !> Read install config from toml table (no checks made at this stage)
+  subroutine load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fortran_config_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call get_value(table, "implicit-typing", self%implicit_typing, error, class_name)
+    if (allocated(error)) return
+    call get_value(table, "implicit-external", self%implicit_external, error, class_name)
+    if (allocated(error)) return
+    call get_value(table, "source-form", self%source_form)
+
+  end subroutine load_from_toml
+
+
 end module fpm_manifest_fortran
diff --git a/src/fpm/manifest/install.f90 b/src/fpm/manifest/install.f90
index 6175873937..88c3097eb0 100644
--- a/src/fpm/manifest/install.f90
+++ b/src/fpm/manifest/install.f90
@@ -7,25 +7,32 @@
 !>```
 module fpm_manifest_install
   use fpm_error, only : error_t, fatal_error, syntax_error
-  use fpm_toml, only : toml_table, toml_key, toml_stat, get_value
+  use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, set_value, serializable_t
   implicit none
   private
 
   public :: install_config_t, new_install_config
 
   !> Configuration data for installation
-  type :: install_config_t
+  type, extends(serializable_t) :: install_config_t
 
     !> Install library with this project
-    logical :: library
+    logical :: library = .false.
 
   contains
 
     !> Print information on this instance
     procedure :: info
 
+    !> Serialization interface
+    procedure :: serializable_is_same => install_conf_same
+    procedure :: dump_to_toml
+    procedure :: load_from_toml
+
   end type install_config_t
 
+  character(*), parameter, private :: class_name = 'install_config_t'
+
 contains
 
   !> Create a new installation configuration from a TOML data structure
@@ -105,4 +112,58 @@ subroutine info(self, unit, verbosity)
 
   end subroutine info
 
+  logical function install_conf_same(this,that)
+    class(install_config_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    install_conf_same = .false.
+
+    select type (other=>that)
+       type is (install_config_t)
+          if (this%library.neqv.other%library) return
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    install_conf_same = .true.
+
+  end function install_conf_same
+
+  !> Dump install config to toml table
+  subroutine dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(install_config_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call set_value(table, "library", self%library, error, class_name)
+
+  end subroutine dump_to_toml
+
+  !> Read install config from toml table (no checks made at this stage)
+  subroutine load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(install_config_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: stat
+
+    call get_value(table, "library", self%library, error, class_name)
+    if (allocated(error)) return
+
+  end subroutine load_from_toml
+
 end module fpm_manifest_install
diff --git a/src/fpm/manifest/library.f90 b/src/fpm/manifest/library.f90
index 68ccc203ef..52e33efecb 100644
--- a/src/fpm/manifest/library.f90
+++ b/src/fpm/manifest/library.f90
@@ -10,8 +10,9 @@
 !>```
 module fpm_manifest_library
     use fpm_error, only : error_t, syntax_error
-    use fpm_strings, only: string_t, string_cat
-    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list
+    use fpm_strings, only: string_t, string_cat, operator(==)
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list, serializable_t, set_value, &
+                          set_list, set_string, get_value, get_list
     implicit none
     private
 
@@ -19,7 +20,7 @@ module fpm_manifest_library
 
 
     !> Configuration meta data for a library
-    type :: library_config_t
+    type, extends(serializable_t) :: library_config_t
 
         !> Source path prefix
         character(len=:), allocatable :: source_dir
@@ -35,8 +36,15 @@ module fpm_manifest_library
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => library_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
+
     end type library_config_t
 
+    character(*), parameter, private :: class_name = 'library_config_t'
+
 
 contains
 
@@ -138,5 +146,69 @@ subroutine info(self, unit, verbosity)
 
     end subroutine info
 
+    logical function library_is_same(this,that)
+       class(library_config_t), intent(in) :: this
+       class(serializable_t), intent(in) :: that
+
+        library_is_same = .false.
+
+        select type (other=>that)
+           type is (library_config_t)
+              if (.not.this%include_dir==other%include_dir) return
+              if (.not.allocated(this%source_dir).eqv.allocated(other%source_dir)) return
+              if (.not.this%source_dir==other%source_dir) return
+              if (.not.allocated(this%build_script).eqv.allocated(other%build_script)) return
+              if (.not.this%build_script==other%build_script) return
+           class default
+              ! Not the same type
+              return
+        end select
+
+        !> All checks passed!
+        library_is_same = .true.
+
+    end function library_is_same
+
+    !> Dump install config to toml table
+    subroutine dump_to_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(library_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        call set_string(table, "source-dir", self%source_dir, error, class_name)
+        if (allocated(error)) return
+        call set_string(table, "build-script", self%build_script, error, class_name)
+        if (allocated(error)) return
+        call set_list(table, "include-dir", self%include_dir, error)
+        if (allocated(error)) return
+
+    end subroutine dump_to_toml
+
+    !> Read install config from toml table (no checks made at this stage)
+    subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(library_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        call get_value(table, "source-dir", self%source_dir)
+        if (allocated(error)) return
+        call get_value(table, "build-script", self%build_script)
+        if (allocated(error)) return
+        call get_list(table, "include-dir", self%include_dir, error)
+
+    end subroutine load_from_toml
+
 
 end module fpm_manifest_library
diff --git a/src/fpm/manifest/package.f90 b/src/fpm/manifest/package.f90
index 6c8fed4bb0..78bbb4d4df 100644
--- a/src/fpm/manifest/package.f90
+++ b/src/fpm/manifest/package.f90
@@ -47,7 +47,8 @@ module fpm_manifest_package
     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
+    use fpm_toml, only : toml_table, toml_array, toml_key, toml_stat, get_value, len, &
+                         serializable_t, set_value, set_string, set_list, add_table
     use fpm_versioning, only : version_t, new_version
     implicit none
     private
@@ -62,7 +63,7 @@ module fpm_manifest_package
 
 
     !> Package meta data
-    type :: package_config_t
+    type, extends(serializable_t) :: package_config_t
 
         !> Name of the package
         character(len=:), allocatable :: name
@@ -85,6 +86,15 @@ module fpm_manifest_package
         !> License meta data
         character(len=:), allocatable :: license
 
+        !> Author meta data
+        character(len=:), allocatable :: author
+
+        !> Maintainer meta data
+        character(len=:), allocatable :: maintainer
+
+        !> Copyright meta data
+        character(len=:), allocatable :: copyright
+
         !> Library meta data
         type(library_config_t), allocatable :: library
 
@@ -114,8 +124,15 @@ module fpm_manifest_package
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => manifest_is_same
+        procedure :: dump_to_toml
+        procedure :: load_from_toml
+
     end type package_config_t
 
+    character(len=*), parameter, private :: class_name = 'package_config_t'
+
 
 contains
 
@@ -157,6 +174,9 @@ subroutine new_package(self, table, root, error)
         endif
 
         call get_value(table, "license", self%license)
+        call get_value(table, "author", self%author)
+        call get_value(table, "maintainer", self%maintainer)
+        call get_value(table, "copyright", self%copyright)
 
         if (len(self%name) <= 0) then
             call syntax_error(error, "Package name must be a non-empty string")
@@ -511,5 +531,555 @@ subroutine unique_programs2(executable_i, executable_j, error)
 
     end subroutine unique_programs2
 
+   logical function manifest_is_same(this,that)
+      class(package_config_t), intent(in) :: this
+      class(serializable_t), intent(in) :: that
+
+      integer :: ii
+
+      manifest_is_same = .false.
+
+      select type (other=>that)
+         type is (package_config_t)
+
+            if (.not.this%name==other%name) return
+            if (.not.this%version==other%version) return
+            if (.not.this%build==other%build) return
+            if (.not.this%install==other%install) return
+            if (.not.this%fortran==other%fortran) return
+            if (.not.this%license==other%license) return
+            if (.not.this%author==other%author) return
+            if (.not.this%maintainer==other%maintainer) return
+            if (.not.this%copyright==other%copyright) return
+            if (allocated(this%library).neqv.allocated(other%library)) return
+            if (allocated(this%library)) then
+                if (.not.this%library==other%library) return
+            endif
+            if (allocated(this%executable).neqv.allocated(other%executable)) return
+            if (allocated(this%executable)) then
+                if (.not.size(this%executable)==size(other%executable)) return
+                do ii=1,size(this%executable)
+                    if (.not.this%executable(ii)==other%executable(ii)) return
+                end do
+            end if
+            if (allocated(this%dependency).neqv.allocated(other%dependency)) return
+            if (allocated(this%dependency)) then
+                if (.not.size(this%dependency)==size(other%dependency)) return
+                do ii=1,size(this%dependency)
+                    if (.not.this%dependency(ii)==other%dependency(ii)) return
+                end do
+            end if
+            if (allocated(this%dev_dependency).neqv.allocated(other%dev_dependency)) return
+            if (allocated(this%dev_dependency)) then
+                if (.not.size(this%dev_dependency)==size(other%dev_dependency)) return
+                do ii=1,size(this%dev_dependency)
+                    if (.not.this%dev_dependency(ii)==other%dev_dependency(ii)) return
+                end do
+            end if
+            if (allocated(this%profiles).neqv.allocated(other%profiles)) return
+            if (allocated(this%profiles)) then
+                if (.not.size(this%profiles)==size(other%profiles)) return
+                do ii=1,size(this%profiles)
+                    if (.not.this%profiles(ii)==other%profiles(ii)) return
+                end do
+            end if
+            if (allocated(this%example).neqv.allocated(other%example)) return
+            if (allocated(this%example)) then
+                if (.not.size(this%example)==size(other%example)) return
+                do ii=1,size(this%example)
+                    if (.not.this%example(ii)==other%example(ii)) return
+                end do
+            end if
+            if (allocated(this%preprocess).neqv.allocated(other%preprocess)) return
+            if (allocated(this%preprocess)) then
+                if (.not.size(this%preprocess)==size(other%preprocess)) return
+                do ii=1,size(this%preprocess)
+                    if (.not.this%preprocess(ii)==other%preprocess(ii)) return
+                end do
+            end if
+            if (allocated(this%test).neqv.allocated(other%test)) return
+            if (allocated(this%test)) then
+                if (.not.size(this%test)==size(other%test)) return
+                do ii=1,size(this%test)
+                    if (.not.this%test(ii)==other%test(ii)) return
+                end do
+            end if
+
+         class default
+            ! Not the same type
+            return
+      end select
+
+      !> All checks passed!
+      manifest_is_same = .true.
+
+    end function manifest_is_same
+
+    !> Dump manifest to toml table
+    subroutine dump_to_toml(self, table, error)
+
+       !> Instance of the serializable object
+       class(package_config_t), intent(inout) :: self
+
+       !> Data structure
+       type(toml_table), intent(inout) :: table
+
+       !> Error handling
+       type(error_t), allocatable, intent(out) :: error
+
+       integer :: ierr, ii
+       type(toml_table), pointer :: ptr,ptr_pkg
+       character(30) :: unnamed
+       character(128) :: profile_name
+
+       call set_string(table, "name", self%name, error, class_name)
+       if (allocated(error)) return
+       call set_string(table, "version", self%version%s(), error, class_name)
+       if (allocated(error)) return
+       call set_string(table, "license", self%license, error, class_name)
+       if (allocated(error)) return
+       call set_string(table, "author", self%author, error, class_name)
+       if (allocated(error)) return
+       call set_string(table, "maintainer", self%maintainer, error, class_name)
+       if (allocated(error)) return
+       call set_string(table, "copyright", self%copyright, error, class_name)
+       if (allocated(error)) return
+
+       call add_table(table, "build", ptr, error, class_name)
+       if (allocated(error)) return
+       call self%build%dump_to_toml(ptr, error)
+       if (allocated(error)) return
+
+       call add_table(table, "fortran", ptr, error, class_name)
+       if (allocated(error)) return
+       call self%fortran%dump_to_toml(ptr, error)
+       if (allocated(error)) return
+
+       call add_table(table, "install", ptr, error, class_name)
+       if (allocated(error)) return
+       call self%install%dump_to_toml(ptr, error)
+       if (allocated(error)) return
+
+       if (allocated(self%library)) then
+           call add_table(table, "library", ptr, error, class_name)
+           if (allocated(error)) return
+           call self%library%dump_to_toml(ptr, error)
+           if (allocated(error)) return
+       end if
+
+       if (allocated(self%executable)) then
+
+           call add_table(table, "executable", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'executable' table ")
+              return
+           end if
+
+           do ii = 1, size(self%executable)
+
+              associate (pkg => self%executable(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'EXECUTABLE',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(executable)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(executable)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%dependency)) then
+
+           call add_table(table, "dependencies", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'dependencies' table ")
+              return
+           end if
+
+           do ii = 1, size(self%dependency)
+
+              associate (pkg => self%dependency(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'DEPENDENCY',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(dependencies)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(dependencies)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%dev_dependency)) then
+
+           call add_table(table, "dev-dependencies", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'dev-dependencies' table ")
+              return
+           end if
+
+           do ii = 1, size(self%dev_dependency)
+
+              associate (pkg => self%dev_dependency(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'DEV-DEPENDENCY',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(dev-dependencies)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(dev-dependencies)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%profiles)) then
+
+           call add_table(table, "profiles", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'profiles' table ")
+              return
+           end if
+
+           do ii = 1, size(self%profiles)
+
+              associate (pkg => self%profiles(ii))
+
+                 !> Duplicate profile names are possible, as multiple profiles are possible with the
+                 !> same name, same compiler, etc. So, use a unique name here
+                 write(profile_name,2) ii
+                 call add_table(ptr_pkg, trim(profile_name), ptr, error, class_name//'(profiles)')
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%example)) then
+
+           call add_table(table, "example", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'example' table ")
+              return
+           end if
+
+           do ii = 1, size(self%example)
+
+              associate (pkg => self%example(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'EXAMPLE',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(example)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(example)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%test)) then
+
+           call add_table(table, "test", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'test' table ")
+              return
+           end if
+
+           do ii = 1, size(self%test)
+
+              associate (pkg => self%test(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'TEST',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(test)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(test)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       if (allocated(self%preprocess)) then
+
+           call add_table(table, "preprocess", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, class_name//" cannot create 'preprocess' table ")
+              return
+           end if
+
+           do ii = 1, size(self%preprocess)
+
+              associate (pkg => self%preprocess(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) 'PREPROCESS',ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, class_name//'(preprocess)')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, class_name//'(preprocess)')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+       end if
+
+       1 format('UNNAMED_',a,'_',i0)
+       2 format('PROFILE_',i0)
+
+     end subroutine dump_to_toml
+
+     !> Read manifest from toml table (no checks made at this stage)
+     subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(package_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(toml_key), allocatable :: keys(:),pkg_keys(:)
+        integer :: ierr, ii, jj
+        character(len=:), allocatable :: flag
+        type(toml_table), pointer :: ptr,ptr_pkg
+
+        call table%get_keys(keys)
+
+        call get_value(table, "name", self%name)
+        call get_value(table, "license", self%license)
+        call get_value(table, "author", self%author)
+        call get_value(table, "maintainer", self%maintainer)
+        call get_value(table, "copyright", self%copyright)
+        call get_value(table, "version", flag)
+        call new_version(self%version, flag, error)
+        if (allocated(error)) then
+           error%message = class_name//': version error from TOML table - '//error%message
+           return
+        endif
+
+        if (allocated(self%library)) deallocate(self%library)
+        if (allocated(self%executable)) deallocate(self%executable)
+        if (allocated(self%dependency)) deallocate(self%dependency)
+        if (allocated(self%dev_dependency)) deallocate(self%dev_dependency)
+        if (allocated(self%profiles)) deallocate(self%profiles)
+        if (allocated(self%example)) deallocate(self%example)
+        if (allocated(self%test)) deallocate(self%test)
+        if (allocated(self%preprocess)) deallocate(self%preprocess)
+        sub_deps: do ii = 1, size(keys)
+
+           select case (keys(ii)%key)
+              case ("build")
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving '//keys(ii)%key//' table')
+                      return
+                   end if
+                   call self%build%load_from_toml(ptr, error)
+                   if (allocated(error)) return
+
+              case ("install")
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving '//keys(ii)%key//' table')
+                      return
+                   end if
+                   call self%install%load_from_toml(ptr, error)
+
+              case ("fortran")
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving '//keys(ii)%key//' table')
+                      return
+                   end if
+                   call self%fortran%load_from_toml(ptr, error)
+
+              case ("library")
+
+                   allocate(self%library)
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving '//keys(ii)%key//' table')
+                      return
+                   end if
+                   call self%library%load_from_toml(ptr, error)
+
+              case ("executable")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving executable table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%executable(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%executable(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("dependencies")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving dependency table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%dependency(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%dependency(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("dev-dependencies")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving dev-dependencies table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%dev_dependency(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%dev_dependency(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("profiles")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving profiles table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%profiles(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%profiles(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("example")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving example table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%example(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%example(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("test")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving test table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%test(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%test(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case ("preprocess")
+
+                   call get_value(table, keys(ii), ptr)
+                   if (.not.associated(ptr)) then
+                      call fatal_error(error,class_name//': error retrieving preprocess table')
+                      return
+                   end if
+
+                   !> Read all packages
+                   call ptr%get_keys(pkg_keys)
+                   allocate(self%preprocess(size(pkg_keys)))
+
+                   do jj = 1, size(pkg_keys)
+                      call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                      call self%preprocess(jj)%load_from_toml(ptr_pkg, error)
+                      if (allocated(error)) return
+                   end do
+
+              case default
+                    cycle sub_deps
+           end select
+
+        end do sub_deps
+
+     end subroutine load_from_toml
 
 end module fpm_manifest_package
diff --git a/src/fpm/manifest/preprocess.f90 b/src/fpm/manifest/preprocess.f90
index 538652c29a..49ad24f82d 100644
--- a/src/fpm/manifest/preprocess.f90
+++ b/src/fpm/manifest/preprocess.f90
@@ -12,15 +12,17 @@
 
 module fpm_manifest_preprocess
    use fpm_error, only : error_t, syntax_error
-   use fpm_strings, only : string_t
-   use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list
+   use fpm_strings, only : string_t, operator(==)
+   use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, get_list, serializable_t, set_value, set_list, &
+                        set_string
+   use,intrinsic :: iso_fortran_env, only : stderr=>error_unit
    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 :: preprocess_config_t
+   type, extends(serializable_t) :: preprocess_config_t
 
       !> Name of the preprocessor
       character(len=:), allocatable :: name
@@ -39,8 +41,27 @@ module fpm_manifest_preprocess
       !> Print information on this instance
       procedure :: info
 
+      !> Serialization interface
+      procedure :: serializable_is_same => preprocess_is_same
+      procedure :: dump_to_toml
+      procedure :: load_from_toml
+
+      !> Operations
+      procedure :: destroy
+      procedure :: add_config
+
+      !> Properties
+      procedure :: is_cpp
+      procedure :: is_fypp
+
    end type preprocess_config_t
 
+   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
@@ -154,7 +175,7 @@ subroutine info(self, unit, verbosity)
          pr = 1
       end if
 
-      if (pr < 1) return 
+      if (pr < 1) return
 
       write(unit, fmt) "Preprocessor"
       if (allocated(self%name)) then
@@ -181,4 +202,146 @@ subroutine info(self, unit, verbosity)
 
    end subroutine info
 
+   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)
+         type is (preprocess_config_t)
+            if (allocated(this%name).neqv.allocated(other%name)) return
+            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
+
+         class default
+            ! Not the same type
+            return
+      end select
+
+      !> All checks passed!
+      preprocess_is_same = .true.
+
+    end function preprocess_is_same
+
+    !> Dump install config to toml table
+    subroutine dump_to_toml(self, table, error)
+
+       !> Instance of the serializable object
+       class(preprocess_config_t), intent(inout) :: self
+
+       !> Data structure
+       type(toml_table), intent(inout) :: table
+
+       !> Error handling
+       type(error_t), allocatable, intent(out) :: error
+
+       call set_string(table, "name", self%name, error)
+       if (allocated(error)) return
+       call set_list(table, "suffixes", self%suffixes, error)
+       if (allocated(error)) return
+       call set_list(table, "directories", self%directories, error)
+       if (allocated(error)) return
+       call set_list(table, "macros", self%macros, error)
+       if (allocated(error)) return
+
+     end subroutine dump_to_toml
+
+     !> Read install config from toml table (no checks made at this stage)
+     subroutine load_from_toml(self, table, error)
+
+        !> Instance of the serializable object
+        class(preprocess_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        call get_value(table, "name", self%name)
+        call get_list(table, "suffixes", self%suffixes, error)
+        if (allocated(error)) return
+        call get_list(table, "directories", self%directories, error)
+        if (allocated(error)) return
+        call get_list(table, "macros", self%macros, error)
+        if (allocated(error)) return
+
+     end subroutine load_from_toml
+
+    !> Clean preprocessor structure
+    elemental subroutine destroy(this)
+       class(preprocess_config_t), intent(inout) :: this
+
+       if (allocated(this%name))deallocate(this%name)
+       if (allocated(this%suffixes))deallocate(this%suffixes)
+       if (allocated(this%directories))deallocate(this%directories)
+       if (allocated(this%macros))deallocate(this%macros)
+
+    end subroutine destroy
+
+    !> Add preprocessor settings
+    subroutine add_config(this,that)
+       class(preprocess_config_t), intent(inout) :: this
+        type(preprocess_config_t), intent(in) :: that
+
+        if (.not.that%is_cpp()) then
+            write(stderr, '(a)') 'Warning: Preprocessor ' // that%name // &
+                                 ' is not supported; will ignore it'
+            return
+        end if
+
+        if (.not.allocated(this%name)) this%name = that%name
+
+        ! Add macros
+        if (allocated(that%macros)) then
+            if (allocated(this%macros)) then
+                this%macros = [this%macros, that%macros]
+            else
+                allocate(this%macros, source = that%macros)
+            end if
+        endif
+
+        ! Add suffixes
+        if (allocated(that%suffixes)) then
+            if (allocated(this%suffixes)) then
+                this%suffixes = [this%suffixes, that%suffixes]
+            else
+                allocate(this%suffixes, source = that%suffixes)
+            end if
+        endif
+
+        ! Add directories
+        if (allocated(that%directories)) then
+            if (allocated(this%directories)) then
+                this%directories = [this%directories, that%directories]
+            else
+                allocate(this%directories, source = that%directories)
+            end if
+        endif
+
+    end subroutine add_config
+
+    ! Check cpp
+    logical function is_cpp(this)
+       class(preprocess_config_t), intent(in) :: this
+       is_cpp = .false.
+       if (allocated(this%name)) is_cpp = this%name == "cpp"
+    end function is_cpp
+
+    ! Check cpp
+    logical function is_fypp(this)
+       class(preprocess_config_t), intent(in) :: this
+       is_fypp = .false.
+       if (allocated(this%name)) is_fypp = this%name == "fypp"
+    end function is_fypp
+
 end module fpm_manifest_preprocess
diff --git a/src/fpm/manifest/profiles.f90 b/src/fpm/manifest/profiles.f90
index 8f1e82eaa5..f50cf32cff 100644
--- a/src/fpm/manifest/profiles.f90
+++ b/src/fpm/manifest/profiles.f90
@@ -43,10 +43,11 @@
 !>
 module fpm_manifest_profile
     use fpm_error, only : error_t, syntax_error, fatal_error, fpm_stop
-    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value
+    use fpm_toml, only : toml_table, toml_key, toml_stat, get_value, serializable_t, set_value, &
+                         set_string, add_table
     use fpm_strings, only: lower
     use fpm_environment, only: get_os_type, OS_UNKNOWN, OS_LINUX, OS_MACOS, OS_WINDOWS, &
-                             OS_CYGWIN, OS_SOLARIS, OS_FREEBSD, OS_OPENBSD
+                             OS_CYGWIN, OS_SOLARIS, OS_FREEBSD, OS_OPENBSD, OS_NAME
     use fpm_filesystem, only: join_path
     implicit none
     public :: profile_config_t, new_profile, new_profiles, get_default_profiles, &
@@ -58,7 +59,7 @@ module fpm_manifest_profile
     character(len=:), allocatable :: path
 
     !> Type storing file name - file scope compiler flags pairs
-    type :: file_scope_flag
+    type, extends(serializable_t) :: file_scope_flag
 
       !> Name of the file
       character(len=:), allocatable :: file_name
@@ -66,10 +67,17 @@ module fpm_manifest_profile
       !> File scope flags
       character(len=:), allocatable :: flags
 
+      contains
+
+          !> Serialization interface
+          procedure :: serializable_is_same => file_scope_same
+          procedure :: dump_to_toml => file_scope_dump
+          procedure :: load_from_toml => file_scope_load
+
     end type file_scope_flag
 
     !> Configuration meta data for a profile
-    type :: profile_config_t
+    type, extends(serializable_t) :: profile_config_t
       !> Name of the profile
       character(len=:), allocatable :: profile_name
 
@@ -77,7 +85,7 @@ module fpm_manifest_profile
       character(len=:), allocatable :: compiler
 
       !> Value repesenting OS
-      integer :: os_type
+      integer :: os_type = OS_ALL
 
       !> Fortran compiler flags
       character(len=:), allocatable :: flags
@@ -95,13 +103,18 @@ module fpm_manifest_profile
       type(file_scope_flag), allocatable :: file_scope_flags(:)
 
       !> Is this profile one of the built-in ones?
-      logical :: is_built_in
+      logical :: is_built_in = .false.
 
       contains
 
         !> Print information on this instance
         procedure :: info
 
+        !> Serialization interface
+        procedure :: serializable_is_same => profile_same
+        procedure :: dump_to_toml => profile_dump
+        procedure :: load_from_toml => profile_load
+
     end type profile_config_t
 
     contains
@@ -221,7 +234,8 @@ subroutine match_os_type(os_name, os_type)
 
         select case (os_name)
           case ("linux");   os_type = OS_LINUX
-          case ("macos");   os_type = OS_WINDOWS
+          case ("macos");   os_type = OS_MACOS
+          case ("windows"); os_type = OS_WINDOWS
           case ("cygwin");  os_type = OS_CYGWIN
           case ("solaris"); os_type = OS_SOLARIS
           case ("freebsd"); os_type = OS_FREEBSD
@@ -232,6 +246,22 @@ subroutine match_os_type(os_name, os_type)
 
       end subroutine match_os_type
 
+      !> Match lowercase string with name of OS to os_type enum
+      function os_type_name(os_type)
+
+        !> Name of operating system
+        character(len=:), allocatable :: os_type_name
+
+        !> Enum representing type of OS
+        integer, intent(in) :: os_type
+
+        select case (os_type)
+          case (OS_ALL); os_type_name = "all"
+          case default; os_type_name = lower(OS_NAME(os_type))
+        end select
+
+      end function os_type_name
+
       subroutine validate_profile_table(profile_name, compiler_name, key_list, table, error, os_valid)
 
         !> Name of profile
@@ -836,7 +866,7 @@ subroutine info(self, unit, verbosity)
             write(unit, fmt) "- compiler", self%compiler
         end if
 
-        write(unit, fmt) "- os", self%os_type
+        write(unit, fmt) "- os", os_type_name(self%os_type)
 
         if (allocated(self%flags)) then
             write(unit, fmt) "- compiler flags", self%flags
@@ -954,4 +984,256 @@ subroutine find_profile(profiles, profile_name, compiler, os_type, found_matchin
           end do
         end if
       end subroutine find_profile
+
+
+      logical function file_scope_same(this,that)
+          class(file_scope_flag), intent(in) :: this
+          class(serializable_t), intent(in) :: that
+
+          file_scope_same = .false.
+
+          select type (other=>that)
+             type is (file_scope_flag)
+                if (allocated(this%file_name).neqv.allocated(other%file_name)) return
+                if (allocated(this%file_name)) then
+                    if (.not.(this%file_name==other%file_name)) return
+                endif
+                if (allocated(this%flags).neqv.allocated(other%flags)) return
+                if (allocated(this%flags)) then
+                    if (.not.(this%flags==other%flags)) return
+                endif
+
+             class default
+                ! Not the same type
+                return
+          end select
+
+          !> All checks passed!
+          file_scope_same = .true.
+
+    end function file_scope_same
+
+    !> Dump to toml table
+    subroutine file_scope_dump(self, table, error)
+
+       !> Instance of the serializable object
+       class(file_scope_flag), intent(inout) :: self
+
+       !> Data structure
+       type(toml_table), intent(inout) :: table
+
+       !> Error handling
+       type(error_t), allocatable, intent(out) :: error
+
+       call set_string(table, "file-name", self%file_name, error)
+       if (allocated(error)) return
+       call set_string(table, "flags", self%flags, error)
+       if (allocated(error)) return
+
+     end subroutine file_scope_dump
+
+     !> Read from toml table (no checks made at this stage)
+     subroutine file_scope_load(self, table, error)
+
+        !> Instance of the serializable object
+        class(file_scope_flag), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        call get_value(table, "file-name", self%file_name)
+        call get_value(table, "flags", self%flags)
+
+     end subroutine file_scope_load
+
+      logical function profile_same(this,that)
+          class(profile_config_t), intent(in) :: this
+          class(serializable_t), intent(in) :: that
+
+          integer :: ii
+
+          profile_same = .false.
+
+          select type (other=>that)
+             type is (profile_config_t)
+                if (allocated(this%profile_name).neqv.allocated(other%profile_name)) return
+                if (allocated(this%profile_name)) then
+                    if (.not.(this%profile_name==other%profile_name)) return
+                endif
+                if (allocated(this%compiler).neqv.allocated(other%compiler)) return
+                if (allocated(this%compiler)) then
+                    if (.not.(this%compiler==other%compiler)) return
+                endif
+                if (this%os_type/=other%os_type) return
+                if (allocated(this%flags).neqv.allocated(other%flags)) return
+                if (allocated(this%flags)) then
+                    if (.not.(this%flags==other%flags)) return
+                endif
+                if (allocated(this%c_flags).neqv.allocated(other%c_flags)) return
+                if (allocated(this%c_flags)) then
+                    if (.not.(this%c_flags==other%c_flags)) return
+                endif
+                if (allocated(this%cxx_flags).neqv.allocated(other%cxx_flags)) return
+                if (allocated(this%cxx_flags)) then
+                    if (.not.(this%cxx_flags==other%cxx_flags)) return
+                endif
+                if (allocated(this%link_time_flags).neqv.allocated(other%link_time_flags)) return
+                if (allocated(this%link_time_flags)) then
+                    if (.not.(this%link_time_flags==other%link_time_flags)) return
+                endif
+
+                if (allocated(this%file_scope_flags).neqv.allocated(other%file_scope_flags)) return
+                if (allocated(this%file_scope_flags)) then
+                    if (.not.size(this%file_scope_flags)==size(other%file_scope_flags)) return
+                    do ii=1,size(this%file_scope_flags)
+                        print *, 'check ii-th file scope: ',ii
+                       if (.not.this%file_scope_flags(ii)==other%file_scope_flags(ii)) return
+                    end do
+                endif
+
+                if (this%is_built_in.neqv.other%is_built_in) return
+
+             class default
+                ! Not the same type
+                return
+          end select
+
+          !> All checks passed!
+          profile_same = .true.
+
+    end function profile_same
+
+    !> Dump to toml table
+    subroutine profile_dump(self, table, error)
+
+       !> Instance of the serializable object
+       class(profile_config_t), intent(inout) :: self
+
+       !> Data structure
+       type(toml_table), intent(inout) :: table
+
+       !> Error handling
+       type(error_t), allocatable, intent(out) :: error
+
+       !> Local variables
+       integer :: ierr, ii
+       type(toml_table), pointer :: ptr_deps, ptr
+       character(len=30) :: unnamed
+
+       call set_string(table, "profile-name", self%profile_name, error)
+       if (allocated(error)) return
+       call set_string(table, "compiler", self%compiler, error)
+       if (allocated(error)) return
+       call set_string(table,"os-type",os_type_name(self%os_type), error, 'profile_config_t')
+       if (allocated(error)) return
+       call set_string(table, "flags", self%flags, error)
+       if (allocated(error)) return
+       call set_string(table, "c-flags", self%c_flags, error)
+       if (allocated(error)) return
+       call set_string(table, "cxx-flags", self%cxx_flags, error)
+       if (allocated(error)) return
+       call set_string(table, "link-time-flags", self%link_time_flags, error)
+       if (allocated(error)) return
+
+       if (allocated(self%file_scope_flags)) then
+
+           ! Create dependency table
+           call add_table(table, "file-scope-flags", ptr_deps)
+           if (.not. associated(ptr_deps)) then
+              call fatal_error(error, "profile_config_t cannot create file scope table ")
+              return
+           end if
+
+           do ii = 1, size(self%file_scope_flags)
+              associate (dep => self%file_scope_flags(ii))
+
+                 !> Because files need a name, fallback if this has no name
+                 if (len_trim(dep%file_name)==0) then
+                    write(unnamed,1) ii
+                    call add_table(ptr_deps, trim(unnamed), ptr)
+                 else
+                    call add_table(ptr_deps, dep%file_name, ptr)
+                 end if
+                 if (.not. associated(ptr)) then
+                    call fatal_error(error, "profile_config_t cannot create entry for file "//dep%file_name)
+                    return
+                 end if
+                 call dep%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+              end associate
+           end do
+
+       endif
+
+       call set_value(table, "is-built-in", self%is_built_in, error, 'profile_config_t')
+       if (allocated(error)) return
+
+       1 format('UNNAMED_FILE_',i0)
+
+     end subroutine profile_dump
+
+     !> Read from toml table (no checks made at this stage)
+     subroutine profile_load(self, table, error)
+
+        !> Instance of the serializable object
+        class(profile_config_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        character(len=:), allocatable :: flag
+        integer :: ii, jj
+        type(toml_table), pointer :: ptr_dep, ptr
+        type(toml_key), allocatable :: keys(:),dep_keys(:)
+
+        call table%get_keys(keys)
+
+        call get_value(table, "profile-name", self%profile_name)
+        call get_value(table, "compiler", self%compiler)
+        call get_value(table,"os-type",flag)
+        call match_os_type(flag, self%os_type)
+        call get_value(table, "flags", self%flags)
+        call get_value(table, "c-flags", self%c_flags)
+        call get_value(table, "cxx-flags", self%cxx_flags)
+        call get_value(table, "link-time-flags", self%link_time_flags)
+        call get_value(table, "is-built-in", self%is_built_in, error, 'profile_config_t')
+        if (allocated(error)) return
+
+        if (allocated(self%file_scope_flags)) deallocate(self%file_scope_flags)
+        sub_deps: do ii = 1, size(keys)
+
+           select case (keys(ii)%key)
+              case ("file-scope-flags")
+
+               call get_value(table, keys(ii), ptr)
+               if (.not.associated(ptr)) then
+                  call fatal_error(error,'profile_config_t: error retrieving file_scope_flags table')
+                  return
+               end if
+
+               !> Read all packages
+               call ptr%get_keys(dep_keys)
+               allocate(self%file_scope_flags(size(dep_keys)))
+
+               do jj = 1, size(dep_keys)
+
+                   call get_value(ptr, dep_keys(jj), ptr_dep)
+                   call self%file_scope_flags(jj)%load_from_toml(ptr_dep, error)
+                   if (allocated(error)) return
+
+               end do
+
+           end select
+        end do sub_deps
+
+     end subroutine profile_load
+
+
 end module fpm_manifest_profile
diff --git a/src/fpm/toml.f90 b/src/fpm/toml.f90
index f8d8ea2420..1bbcfe9886 100644
--- a/src/fpm/toml.f90
+++ b/src/fpm/toml.f90
@@ -14,19 +14,295 @@
 !> [TOML-Fortran](https://toml-f.github.io/toml-f) developer pages.
 module fpm_toml
     use fpm_error, only: error_t, fatal_error, file_not_found_error
-    use fpm_strings, only: string_t
+    use fpm_strings, only: string_t, str_ends_with, lower
     use tomlf, only: toml_table, toml_array, toml_key, toml_stat, get_value, &
         & set_value, toml_parse, toml_error, new_table, add_table, add_array, &
-        & toml_serialize, len, toml_load
+        & toml_serialize, len, toml_load, toml_value
+    use tomlf_de_parser, only: parse
+    use jonquil, only: json_serialize, json_error, json_value, json_object, json_load, &
+                       cast_to_object
+    use iso_fortran_env, only: int64
     implicit none
     private
 
     public :: read_package_file, toml_table, toml_array, toml_key, toml_stat, &
               get_value, set_value, get_list, new_table, add_table, add_array, len, &
-              toml_error, toml_serialize, toml_load, check_keys
+              toml_error, toml_serialize, toml_load, check_keys, set_list, set_string, &
+              name_is_json
+
+    !> An abstract interface for any fpm class that should be fully serializable to/from TOML/JSON
+    type, abstract, public :: serializable_t
+
+        contains
+
+        !> Dump to TOML table, unit, file
+        procedure(to_toml), deferred :: dump_to_toml
+        procedure, non_overridable, private :: dump_to_file
+        procedure, non_overridable, private :: dump_to_unit
+        generic :: dump => dump_to_toml, dump_to_file, dump_to_unit
+
+        !> Load from TOML table, unit, file
+        procedure(from_toml), deferred :: load_from_toml
+        procedure, non_overridable, private :: load_from_file
+        procedure, non_overridable, private :: load_from_unit
+        generic :: load => load_from_toml, load_from_file, load_from_unit
+
+        !> Serializable entities need a way to check that they're equal
+        procedure(is_equal), deferred :: serializable_is_same
+        generic :: operator(==) => serializable_is_same
+
+        !> Test load/write roundtrip
+        procedure, non_overridable :: test_serialization
+
+    end type serializable_t
+
+    !> add_table: fpm interface
+    interface add_table
+        module procedure add_table_fpm
+    end interface add_table
+
+    !> set_value: fpm interface
+    interface set_value
+        module procedure set_logical
+        module procedure set_integer
+        module procedure set_integer_64
+    end interface set_value
+
+    interface set_string
+        module procedure set_character
+        module procedure set_string_type
+    end interface set_string
+
+    !> get_value: fpm interface
+    interface get_value
+        module procedure get_logical
+        module procedure get_integer
+        module procedure get_integer_64
+    end interface get_value
+
+
+    abstract interface
+
+      !> Write object to TOML datastructure
+      subroutine to_toml(self, table, error)
+        import serializable_t,toml_table,error_t
+        implicit none
+
+        !> Instance of the serializable object
+        class(serializable_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+      end subroutine to_toml
+
+      !> Read dependency tree from TOML data structure
+      subroutine from_toml(self, table, error)
+        import serializable_t,toml_table,error_t
+        implicit none
+
+        !> Instance of the serializable object
+        class(serializable_t), intent(inout) :: self
+
+        !> Data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+      end subroutine from_toml
+
+      !> Compare two serializable objects
+      logical function is_equal(this,that)
+         import serializable_t
+         class(serializable_t), intent(in) :: this,that
+      end function is_equal
+
+    end interface
 
 contains
 
+    !> Test serialization of a serializable object
+    subroutine test_serialization(self, message, error)
+        class(serializable_t), intent(inout) :: self
+        character(len=*), intent(in) :: message
+        type(error_t), allocatable, intent(out) :: error
+
+        integer :: iunit, ii
+        class(serializable_t), allocatable :: copy
+        character(len=4), parameter :: formats(2) = ['TOML','JSON']
+
+        all_formats: do ii = 1, 2
+
+            open(newunit=iunit,form='formatted',action='readwrite',status='scratch')
+
+            !> Dump to scratch file
+            call self%dump(iunit, error, json=ii==2)
+            if (allocated(error)) then
+                error%message = formats(ii)//': '//error%message
+                return
+            endif
+
+            !> Load from scratch file
+            rewind(iunit)
+            allocate(copy,mold=self)
+            call copy%load(iunit,error, json=ii==2)
+            if (allocated(error)) then
+                error%message = formats(ii)//': '//error%message
+                return
+            endif
+            close(iunit)
+
+            !> Check same
+            if (.not.(self==copy)) then
+                call fatal_error(error,'serializable object failed '//formats(ii)//&
+                                       ' write/reread test: '//trim(message))
+                return
+            end if
+            deallocate(copy)
+
+        end do all_formats
+
+    end subroutine test_serialization
+
+
+    !> Write serializable object to a formatted Fortran unit
+    subroutine dump_to_unit(self, unit, error, json)
+        !> Instance of the dependency tree
+        class(serializable_t), intent(inout) :: self
+        !> Formatted unit
+        integer, intent(in) :: unit
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+        !> Optional JSON format requested?
+        logical, optional, intent(in) :: json
+
+        type(toml_table) :: table
+        logical :: is_json
+
+        is_json = .false.; if (present(json)) is_json = json
+
+        table = toml_table()
+        call self%dump(table, error)
+
+        if (is_json) then
+
+!            !> Deactivate JSON serialization for now
+!            call fatal_error(error, 'JSON serialization option is not yet available')
+!            return
+
+            write (unit, '(a)') json_serialize(table)
+        else
+            write (unit, '(a)') toml_serialize(table)
+        end if
+
+        call table%destroy()
+
+    end subroutine dump_to_unit
+
+    !> Write serializable object to file
+    subroutine dump_to_file(self, file, error, json)
+        !> Instance of the dependency tree
+        class(serializable_t), intent(inout) :: self
+        !> File name
+        character(len=*), intent(in) :: file
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+        !> Optional JSON format
+        logical, optional, intent(in) :: json
+
+        integer :: unit
+
+        open (file=file, newunit=unit)
+        call self%dump(unit, error, json)
+        close (unit)
+        if (allocated(error)) return
+
+    end subroutine dump_to_file
+
+    !> Read dependency tree from file
+    subroutine load_from_file(self, file, error, json)
+        !> Instance of the dependency tree
+        class(serializable_t), intent(inout) :: self
+        !> File name
+        character(len=*), intent(in) :: file
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+        !> Optional JSON format
+        logical, optional, intent(in) :: json
+
+        integer :: unit
+        logical :: exist
+
+        inquire (file=file, exist=exist)
+        if (.not. exist) return
+
+        open (file=file, newunit=unit)
+        call self%load(unit, error, json)
+        close (unit)
+    end subroutine load_from_file
+
+    !> Read dependency tree from file
+    subroutine load_from_unit(self, unit, error, json)
+        !> Instance of the dependency tree
+        class(serializable_t), intent(inout) :: self
+        !> File name
+        integer, intent(in) :: unit
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+        !> Optional JSON format
+        logical, optional, intent(in) :: json
+
+        type(toml_error), allocatable :: local_error
+        type(toml_table), allocatable :: table
+        type(toml_table), pointer     :: jtable
+        class(toml_value), allocatable :: object
+        logical :: is_json
+
+        is_json = .false.; if (present(json)) is_json = json
+
+        if (is_json) then
+
+           !> init JSON interpreter
+           call json_load(object, unit, error=local_error)
+           if (allocated(local_error)) then
+              allocate (error)
+              call move_alloc(local_error%message, error%message)
+              return
+           end if
+
+           jtable => cast_to_object(object)
+           if (.not.associated(jtable)) then
+              call fatal_error(error,'cannot initialize JSON table ')
+              return
+           end if
+
+           !> Read object from TOML table
+           call self%load(jtable, error)
+
+        else
+
+           !> use default TOML parser
+           call toml_load(table, unit, error=local_error)
+
+           if (allocated(local_error)) then
+              allocate (error)
+              call move_alloc(local_error%message, error%message)
+              return
+           end if
+
+           !> Read object from TOML table
+           call self%load(table, error)
+
+        endif
+
+        if (allocated(error)) return
+
+    end subroutine load_from_unit
+
     !> Process the configuration file to a TOML data structure
     subroutine read_package_file(table, manifest, error)
 
@@ -109,6 +385,331 @@ subroutine get_list(table, key, list, error)
 
     end subroutine get_list
 
+    ! Set string array
+    subroutine set_list(table, key, list, error)
+
+        !> Instance of the string array
+        type(string_t), allocatable, intent(in) :: list(:)
+
+        !> Key to save to
+        character(len=*), intent(in) :: key
+
+        !> Instance of the toml table
+        type(toml_table), intent(inout) :: table
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Local variables
+        integer :: stat, ilist
+        type(toml_array), pointer :: children
+        character(len=:), allocatable :: str
+
+        !> Set no key if array is not present
+        if (.not.allocated(list)) return
+
+        !> Check the key is not empty
+        if (len_trim(key)<=0) then
+            call fatal_error(error, 'key is empty dumping string array to TOML table')
+            return
+        end if
+
+        if (size(list)/=1) then ! includes empty list case
+
+            !> String array
+            call add_array(table, key, children, stat)
+            if (stat /= toml_stat%success) then
+                call fatal_error(error, "Cannot set array table in "//key//" field")
+                return
+            end if
+
+            do ilist = 1, size(list)
+                  call set_value(children, ilist, list(ilist)%s, stat=stat)
+                  if (stat /= toml_stat%success) then
+                      call fatal_error(error, "Cannot store array entry in "//key//" field")
+                      return
+                  end if
+            end do
+
+        else
+
+            ! Single value: set string
+            call set_value(table, key, list(1)%s, stat=stat)
+
+            if (stat /= toml_stat%success) &
+            call fatal_error(error, "Cannot store entry in "//key//" field")
+
+            return
+        end if
+
+    end subroutine set_list
+
+    !> Function wrapper to set a character(len=:), allocatable variable to a toml table
+    subroutine set_character(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> List of keys to check.
+        character(len=*), intent(in) :: key
+
+        !> The character variable
+        character(len=*), optional, intent(in) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        !> Check the key is not empty
+        if (len_trim(key)<=0) then
+            call fatal_error(error, 'key is empty setting character string to TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+        if (present(var)) then
+            call set_value(table, key, var, ierr)
+            if (ierr/=toml_stat%success) then
+                call fatal_error(error,'cannot set character key <'//key//'> in TOML table')
+                if (present(whereAt)) error%message = whereAt//': '//error%message
+                return
+            end if
+        endif
+
+    end subroutine set_character
+
+    !> Function wrapper to set a logical variable to a toml table, returning an fpm error
+    subroutine set_logical(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        logical, intent(in) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call set_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot set logical key <'//key//'> in TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine set_logical
+
+    !> Function wrapper to set a default integer variable to a toml table, returning an fpm error
+    subroutine set_integer(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        integer, intent(in) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call set_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot set integer key <'//key//'> in TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine set_integer
+
+    !> Function wrapper to set a default integer variable to a toml table, returning an fpm error
+    subroutine set_integer_64(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        integer(int64), intent(in) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call set_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot set integer(int64) key <'//key//'> in TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine set_integer_64
+
+    !> Function wrapper to set a character(len=:), allocatable variable to a toml table
+    subroutine set_string_type(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> List of keys to check.
+        character(len=*), intent(in) :: key
+
+        !> The character variable
+        type(string_t), intent(in) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        call set_character(table, key, var%s, error, whereAt)
+
+    end subroutine set_string_type
+
+    !> Function wrapper to add a toml table and return an fpm error
+    subroutine add_table_fpm(table, key, ptr, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> Table key
+        character(len=*), intent(in) :: key
+
+        !> The character variable
+        type(toml_table), pointer, intent(out) :: ptr
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        !> Nullify pointer
+        nullify(ptr)
+
+        call add_table(table, key, ptr, ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot add <'//key//'> table in TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine add_table_fpm
+
+    !> Function wrapper to get a logical variable from a toml table, returning an fpm error
+    subroutine get_logical(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        logical, intent(inout) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call get_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot get logical key <'//key//'> from TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine get_logical
+
+    !> Function wrapper to get a default integer variable from a toml table, returning an fpm error
+    subroutine get_integer(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        integer, intent(inout) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call get_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot get integer key <'//key//'> from TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine get_integer
+
+    !> Function wrapper to get a integer(int64) variable from a toml table, returning an fpm error
+    subroutine get_integer_64(table, key, var, error, whereAt)
+
+        !> Instance of the TOML data structure
+        type(toml_table), intent(inout) :: table
+
+        !> The key
+        character(len=*), intent(in) :: key
+
+        !> The variable
+        integer(int64), intent(inout) :: var
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        !> Optional description
+        character(len=*), intent(in), optional :: whereAt
+
+        integer :: ierr
+
+        call get_value(table, key, var, stat=ierr)
+        if (ierr/=toml_stat%success) then
+            call fatal_error(error,'cannot get integer(int64) key <'//key//'> from TOML table')
+            if (present(whereAt)) error%message = whereAt//': '//error%message
+            return
+        end if
+
+    end subroutine get_integer_64
+
     !> Check if table contains only keys that are part of the list. If a key is
     !> found that is not part of the list, an error is allocated.
     subroutine check_keys(table, valid_keys, error)
@@ -123,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
 
@@ -143,15 +745,35 @@ 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
 
     end subroutine check_keys
 
+    !> Choose between JSON or TOML based on a file name
+    logical function name_is_json(filename)
+        character(*), intent(in) :: filename
+
+        character(*), parameter :: json_identifier = ".json"
+
+        name_is_json = .false.
+
+        if (len_trim(filename)<len(json_identifier)) return
+
+        name_is_json = str_ends_with(lower(filename),json_identifier)
+
+    end function name_is_json
+
 end module fpm_toml
diff --git a/src/fpm/versioning.f90 b/src/fpm/versioning.f90
index d1e130a2c3..82f980bc95 100644
--- a/src/fpm/versioning.f90
+++ b/src/fpm/versioning.f90
@@ -230,7 +230,7 @@ pure function s(self) result(string)
         character(len=buffersize) :: buffer
         integer :: ii
 
-        do ii = 1, size(self%num)
+        do ii = 1, ndigits(self)
             if (allocated(string)) then
                 write(buffer, '(".", i0)') self%num(ii)
                 string = string // trim(buffer)
@@ -299,18 +299,18 @@ elemental function greater(lhs, rhs) result(is_greater)
         !> First version is greater
         logical :: is_greater
 
-        integer :: ii
+        integer :: ii, lhs_size, rhs_size
 
-        do ii = 1, min(size(lhs%num), size(rhs%num))
+        do ii = 1, min(ndigits(lhs),ndigits(rhs))
             if (lhs%num(ii) /= rhs%num(ii)) then
                 is_greater = lhs%num(ii) > rhs%num(ii)
                 return
             end if
         end do
 
-        is_greater = size(lhs%num) > size(rhs%num)
+        is_greater = ndigits(lhs) > ndigits(rhs)
         if (is_greater) then
-            do ii = size(rhs%num) + 1, size(lhs%num)
+            do ii = ndigits(rhs) + 1, ndigits(lhs)
                 is_greater = lhs%num(ii) > 0
                 if (is_greater) return
             end do
@@ -393,6 +393,18 @@ elemental function match(lhs, rhs)
 
     end function match
 
+    !> Number of digits
+    elemental integer function ndigits(self)
+       class(version_t), intent(in) :: self
+
+       if (allocated(self%num)) then
+          ndigits = size(self%num)
+       else
+          ndigits = 0
+       end if
+
+    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)
diff --git a/src/fpm_command_line.f90 b/src/fpm_command_line.f90
index bc2b1bf4be..2a9567be50 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_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
@@ -44,6 +44,7 @@ module fpm_command_line
 public :: fpm_cmd_settings, &
           fpm_build_settings, &
           fpm_install_settings, &
+          fpm_export_settings, &
           fpm_new_settings, &
           fpm_run_settings, &
           fpm_test_settings, &
@@ -76,6 +77,7 @@ module fpm_command_line
     logical                      :: show_model=.false.
     logical                      :: build_tests=.false.
     logical                      :: prune=.true.
+    character(len=:),allocatable :: dump
     character(len=:),allocatable :: compiler
     character(len=:),allocatable :: c_compiler
     character(len=:),allocatable :: cxx_compiler
@@ -89,9 +91,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
@@ -108,15 +113,22 @@ module fpm_command_line
 !> Settings for interacting and updating with project dependencies
 type, extends(fpm_cmd_settings)  :: fpm_update_settings
     character(len=ibug),allocatable :: name(:)
-    logical :: fetch_only
-    logical :: clean
+    character(len=:),allocatable    :: dump
+    logical                         :: fetch_only
+    logical                         :: clean
+end type
+
+!> Settings for exporting model data
+type, extends(fpm_build_settings) :: fpm_export_settings
+    character(len=:),allocatable  :: dump_manifest
+    character(len=:),allocatable  :: dump_dependencies
+    character(len=:),allocatable  :: dump_model
 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_all = .false.
+    logical                       :: registry_cache = .false.
 end type
 
 type, extends(fpm_build_settings) :: fpm_publish_settings
@@ -142,7 +154,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_profile, val_runner_args, val_dump
+
 
 !   '12345678901234567890123456789012345678901234567890123456789012345678901234567890',&
 character(len=80), parameter :: help_text_build_common(*) = [character(len=80) ::      &
@@ -170,7 +183,8 @@ 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 ',&
-    '                   options override the defaults. Note object and .mod          ',&
+    '                   are added to the defaults. To override the defaults, use the ',&
+    '                   keyword [fortran] in the manifest. 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       ',&
@@ -218,8 +232,9 @@ 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, token_s, config_file
@@ -244,7 +259,6 @@ subroutine get_command_line_settings(cmd_settings)
             case (OS_UNKNOWN); os_type =  "OS Type:     Unknown"
             case default     ; os_type =  "OS Type:     UNKNOWN"
         end select
-        is_unix = os_is_unix(os)
 
         ! Get current release version
         version = fpm_version()
@@ -269,7 +283,8 @@ subroutine get_command_line_settings(cmd_settings)
         run_args = &
           ' --target " "' // &
           ' --list F' // &
-          ' --runner " "'
+          ' --runner " "' // &
+          ' --runner-args " "'
 
         compiler_args = &
           ' --profile " "' // &
@@ -318,6 +333,11 @@ 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')
@@ -325,6 +345,7 @@ subroutine get_command_line_settings(cmd_settings)
             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,&
@@ -343,12 +364,14 @@ 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')
             call set_args(common_args // compiler_args //'&
             & --list F &
             & --show-model F &
+            & --dump " " &
             & --tests F &
             & --config-file " " &
             & --',help_build,version_text)
@@ -359,10 +382,13 @@ subroutine get_command_line_settings(cmd_settings)
             cxx_compiler = sget('cxx-compiler')
             archiver = sget('archiver')
             config_file = sget('config-file')
+            val_dump = sget('dump')
+            if (specified('dump') .and. val_dump=='')val_dump='fpm_model.toml'
 
             allocate( fpm_build_settings :: cmd_settings )
             cmd_settings=fpm_build_settings(  &
             & profile=val_profile,&
+            & dump=val_dump,&
             & prune=.not.lget('no-prune'), &
             & compiler=val_compiler, &
             & c_compiler=c_compiler, &
@@ -578,6 +604,11 @@ 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')
@@ -586,6 +617,7 @@ subroutine get_command_line_settings(cmd_settings)
             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, &
@@ -604,12 +636,14 @@ 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 " " &
             & --config-file " " &
             &', help_update, version_text)
 
@@ -619,33 +653,81 @@ subroutine get_command_line_settings(cmd_settings)
                 names=[character(len=len(names)) :: ]
             endif
 
+
             config_file = sget('config-file')
+            val_dump = sget('dump')
+            if (specified('dump') .and. val_dump=='')val_dump='fpm_dependencies.toml'
+
 
             allocate(fpm_update_settings :: cmd_settings)
             cmd_settings=fpm_update_settings(name=names, &
             & fetch_only=lget('fetch-only'), &
+            & dump=val_dump, &
+            & fetch_only=lget('fetch-only'), &
             & verbose=lget('verbose'), &
             & path_to_config=config_file, &
             & clean=lget('clean'))
 
-        case('clean')
-            call set_args(common_args // '&
-            & --skip &
-            & --all &
-            & --config-file " " &
-            &', help_clean, version_text)
+        case('export')
+
+            call set_args(common_args // compiler_args // '&
+                & --manifest "filename"  &
+                & --model "filename" &
+                & --dependencies "filename" ', &
+                help_build, version_text)
+
+            call check_build_vals()
+
+            c_compiler = sget('c-compiler')
+            cxx_compiler = sget('cxx-compiler')
+            archiver = sget('archiver')
+            allocate(export_settings, source=fpm_export_settings(&
+                profile=val_profile,&
+                prune=.not.lget('no-prune'), &
+                compiler=val_compiler, &
+                c_compiler=c_compiler, &
+                cxx_compiler=cxx_compiler, &
+                archiver=archiver, &
+                flag=val_flag, &
+                cflag=val_cflag, &
+                show_model=.true., &
+                cxxflag=val_cxxflag, &
+                ldflag=val_ldflag, &
+                verbose=lget('verbose')))
+            call get_char_arg(export_settings%dump_model, 'model')
+            call get_char_arg(export_settings%dump_manifest, 'manifest')
+            call get_char_arg(export_settings%dump_dependencies, 'dependencies')
+            call move_alloc(export_settings, cmd_settings)
 
-            config_file = sget('config-file')
 
-            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'), &
-            & path_to_config=config_file &
-            &)
+        case('clean')
+            call set_args(common_args // &
+            &   ' --registry-cache'   // &
+            &   ' --skip'             // &
+            &   ' --all'              // &
+            &   ' --config-file ""', help_clean, version_text)
+
+            block
+                logical :: skip, clean_all
+                character(len=256) :: config_file
+
+                skip = lget('skip')
+                clean_all = lget('all')
+                config_file = sget('config-file')
+
+                if (all([skip, clean_all])) then
+                    call fpm_stop(6, 'Do not specify both --skip and --all options on the clean subcommand.')
+                end if
+
+                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=skip, &
+                &   clean_all=clean_all, &
+                &   path_to_config=config_file)
+            end block
 
         case('publish')
             call set_args(common_args // compiler_args //'&
@@ -776,11 +858,11 @@ subroutine set_help()
    help_list_dash = [character(len=80) :: &
    '                                                                                ', &
    ' build [--compiler COMPILER_NAME] [--profile PROF] [--flag FFLAGS] [--list]     ', &
-   '       [--tests] [--no-prune] [--config-file PATH]                              ', &
+   '       [--tests] [--no-prune] [--dump [FILENAME]] [--config-file PATH]          ', &
    ' help [NAME(s)]                                                                 ', &
    ' new NAME [[--lib|--src] [--app] [--test] [--example]]|                         ', &
    '          [--full|--bare][--backfill]                                           ', &
-   ' update [NAME(s)] [--fetch-only] [--clean] [--verbose] [--config-file PATH]     ', &
+   ' update [NAME(s)] [--fetch-only] [--clean] [--verbose] [--dump [FILENAME]]      ', &
    ' list [--list]                                                                  ', &
    ' run  [[--target] NAME(s) [--example] [--profile PROF] [--flag FFLAGS] [--all]  ', &
    '      [--runner "CMD"] [--compiler COMPILER_NAME] [--list] [-- ARGS]            ', &
@@ -788,8 +870,8 @@ subroutine set_help()
    ' test [[--target] NAME(s)] [--profile PROF] [--flag FFLAGS] [--runner "CMD"]    ', &
    '      [--list] [--compiler COMPILER_NAME] [--config-file PATH] [-- ARGS]        ', &
    ' install [--profile PROF] [--flag FFLAGS] [--no-rebuild] [--prefix PATH]        ', &
-   '         [--config-file PATH] [options]                                         ', &
-   ' clean [--skip] [--all] [--config-file PATH]                                    ', &
+   '         [--config-file PATH] [--registry-cache] [options]                      ', &
+   ' clean [--skip] [--all] [--config-file PATH] [--registry-cache]                 ', &
    ' publish [--token TOKEN] [--show-package-version] [--show-upload-data]          ', &
    '         [--dry-run] [--verbose] [--config-file PATH]                           ', &
    ' ']
@@ -801,7 +883,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                    ', &
@@ -817,8 +899,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:                            ', &
@@ -847,6 +932,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''                                     ', &
@@ -901,10 +987,10 @@ subroutine set_help()
     '  Their syntax is                                                      ', &
     '                                                                                ', &
     '    build [--profile PROF] [--flag FFLAGS] [--list] [--compiler COMPILER_NAME]  ', &
-    '          [--tests] [--no-prune] [--config-file PATH]                           ', &
+    '          [--tests] [--no-prune] [--config-file PATH] [--dump [FILENAME]]       ', &
     '    new NAME [[--lib|--src] [--app] [--test] [--example]]|                      ', &
     '             [--full|--bare][--backfill]                                        ', &
-    '    update [NAME(s)] [--fetch-only] [--clean] [--config-file PATH]              ', &
+    '    update [NAME(s)] [--fetch-only] [--clean] [--config-file PATH] [--dump [FILENAME]]', &
     '    run [[--target] NAME(s)] [--profile PROF] [--flag FFLAGS] [--list] [--all]  ', &
     '        [--example] [--runner "CMD"] [--compiler COMPILER_NAME]                 ', &
     '        [--no-prune] [-- ARGS] [--config-file PATH]                             ', &
@@ -914,8 +1000,8 @@ subroutine set_help()
     '    help [NAME(s)]                                                              ', &
     '    list [--list]                                                               ', &
     '    install [--profile PROF] [--flag FFLAGS] [--no-rebuild] [--prefix PATH]     ', &
-    '            [options] [--config-file PATH]                                      ', &
-    '    clean [--skip] [--all] [--config-file PATH]                                 ', &
+    '            [options] [--config-file PATH] [--registry-cache]                    ', &
+    '    clean [--skip] [--all] [--config-file PATH] [--registry-cache]               ', &
     '    publish [--token TOKEN] [--show-package-version] [--show-upload-data]       ', &
     '            [--dry-run] [--verbose] [--config-file PATH]                        ', &
     '                                                                                ', &
@@ -927,12 +1013,15 @@ subroutine set_help()
     help_text_flag, &
     '  --list     List candidates instead of building or running them. On   ', &
     '             the fpm(1) command this shows a brief list of subcommands.', &
-    '  --runner CMD   Provides a command to prefix program execution paths. ', &
+    '  --runner CMD  Provides a command to prefix program execution paths.  ', &
     '  -- ARGS    Arguments to pass to executables.                         ', &
     '  --skip     Delete directories in the build/ directory without        ', &
-    '             prompting, but skip dependencies.                         ', &
+    '             prompting, but skip dependencies. Cannot be used together ', &
+    '             with --all.                                               ', &
     '  --all      Delete directories in the build/ directory without        ', &
-    '             prompting, including dependencies.                        ', &
+    '             prompting, including dependencies. Cannot be used together', &
+    '             with --skip.                                              ', &
+    '  --registry-cache  Delete registry cache.                             ', &
     '                                                                       ', &
     'VALID FOR ALL SUBCOMMANDS                                              ', &
     '  --help     Show help text and exit                                   ', &
@@ -990,7 +1079,7 @@ subroutine set_help()
     ' + The fpm(1) home page is at https://github.com/fortran-lang/fpm               ', &
     ' + Registered fpm(1) packages are at https://fortran-lang.org/packages          ', &
     ' + The fpm(1) TOML file format is described at                                  ', &
-    '   https://fpm.fortran-lang.org/en/spec/manifest.html                           ', &
+    '   https://fpm.fortran-lang.org/spec/manifest.html                              ', &
     '']
     help_list=[character(len=80) :: &
     'NAME                                                                   ', &
@@ -1091,7 +1180,7 @@ subroutine set_help()
     '                                                                       ', &
     'SYNOPSIS                                                               ', &
     ' fpm build [--profile PROF] [--flag FFLAGS] [--compiler COMPILER_NAME] ', &
-    '           [--list] [--tests] [--config-file PATH]                     ', &
+    '           [--list] [--tests] [--config-file PATH] [--dump [FILENAME]] ', &
     '                                                                       ', &
     ' fpm build --help|--version                                            ', &
     '                                                                       ', &
@@ -1119,6 +1208,9 @@ subroutine set_help()
     ' --list              list candidates instead of building or running them', &
     ' --tests             build all tests (otherwise only if needed)         ', &
     ' --show-model        show the model and exit (do not build)             ', &
+    ' --dump [FILENAME]   save model representation to file. use JSON format ', &
+    '                     if file name is *.json; use TOML format otherwise  ', &
+    '                     (default file name: model.toml)                    ', &
     ' --help              print this help and exit                           ', &
     ' --version           print program version information and exit         ', &
     ' --config-file PATH  custom location of the global config file          ', &
@@ -1323,7 +1415,7 @@ subroutine set_help()
     ' update(1) - manage project dependencies', &
     '', &
     'SYNOPSIS', &
-    ' fpm update [--fetch-only] [--clean] [--verbose] [NAME(s)] ', &
+    ' fpm update [--fetch-only] [--clean] [--verbose] [--dump [FILENAME]] [NAME(s)]', &
     '            [--config-file PATH] ', &
     '', &
     'DESCRIPTION', &
@@ -1335,6 +1427,9 @@ subroutine set_help()
     ' --clean             Do not use previous dependency cache', &
     ' --config-file PATH  Custom location of the global config file', &
     ' --verbose           Show additional printout', &
+    ' --dump [FILENAME]   Dump updated dependency tree to file. use JSON format  ', &
+    '                     if file name is *.json; use TOML format otherwise      ', &
+    '                     (default file name: fpm_dependencies.toml)             ', &
     '', &
     'SEE ALSO', &
     ' The fpm(1) home page at https://github.com/fortran-lang/fpm', &
@@ -1397,11 +1492,13 @@ subroutine set_help()
     'DESCRIPTION', &
     ' Prompts the user to confirm deletion of the build. If affirmative,', &
     ' directories in the build/ directory are deleted, except dependencies.', &
+    ' Use the --registry-cache option to delete the registry cache.', &
     '', &
     'OPTIONS', &
     ' --skip              Delete the build without prompting but skip dependencies.', &
     ' --all               Delete the build without prompting including dependencies.', &
     ' --config-file PATH  Custom location of the global config file.', &
+    ' --registry-cache    Delete registry cache.', &
     '' ]
     help_publish=[character(len=80) :: &
     'NAME', &
@@ -1416,7 +1513,7 @@ subroutine set_help()
     'DESCRIPTION', &
     ' Follow the steps to create a tarball and upload a package to the registry:', &
     '', &
-    '  1. Register on the website (https://registry-frontend.vercel.app/).', &
+    '  1. Register on the website (https://registry-phi.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.', &
@@ -1430,10 +1527,10 @@ subroutine set_help()
     ' See documentation for more information regarding package upload and usage:', &
     '', &
     ' Package upload:', &
-    ' https://fpm.fortran-lang.org/en/spec/publish.html', &
+    ' https://fpm.fortran-lang.org/spec/publish.html', &
     '', &
     ' Package usage:', &
-    ' https://fpm.fortran-lang.org/en/spec/manifest.html#dependencies-from-a-registry', &
+    ' https://fpm.fortran-lang.org/spec/manifest.html#dependencies-from-a-registry', &
     '', &
     'OPTIONS', &
     ' --show-package-version   show package version without publishing', &
@@ -1473,4 +1570,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 02b99af135..f173267659 100644
--- a/src/fpm_compiler.F90
+++ b/src/fpm_compiler.F90
@@ -40,7 +40,9 @@ module fpm_compiler
 use fpm_filesystem, only: join_path, basename, get_temp_filename, delete_file, unix_path, &
     & getline, run
 use fpm_strings, only: split, string_cat, string_t, str_ends_with, str_begins_with_str
-use fpm_error, only: error_t
+use fpm_manifest, only : package_config_t
+use fpm_error, only: error_t, fatal_error
+use fpm_toml, only: serializable_t, toml_table, set_string, set_value, toml_stat, get_value
 implicit none
 public :: compiler_t, new_compiler, archiver_t, new_archiver, get_macros
 public :: debug
@@ -72,7 +74,7 @@ module fpm_compiler
 
 
 !> Definition of compiler object
-type :: compiler_t
+type, extends(serializable_t) :: compiler_t
     !> Identifier of the compiler
     integer(compiler_enum) :: id = id_unknown
     !> Path to the Fortran compiler
@@ -112,13 +114,19 @@ module fpm_compiler
     procedure :: is_gnu
     !> Enumerate libraries, based on compiler and platform
     procedure :: enumerate_libraries
+
+    !> Serialization interface
+    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
 
 
 !> Definition of archiver object
-type :: archiver_t
+type, extends(serializable_t) :: archiver_t
     !> Path to archiver
     character(len=:), allocatable :: ar
     !> Use response files to pass arguments
@@ -130,6 +138,12 @@ module fpm_compiler
 contains
     !> Create static archive
     procedure :: make_archive
+
+    !> Serialization interface
+    procedure :: serializable_is_same => ar_is_same
+    procedure :: dump_to_toml
+    procedure :: load_from_toml
+
 end type archiver_t
 
 
@@ -173,6 +187,7 @@ 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", &
@@ -184,11 +199,15 @@ module fpm_compiler
     flag_intel_fixed_form = " -fixed", &
     flag_intel_standard_compliance = " -standard-semantics"
 
+character(*), parameter :: &
+    flag_intel_llvm_check = " -check all,nouninit"
+
 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", &
@@ -280,6 +299,7 @@ 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//&
@@ -290,6 +310,7 @@ subroutine get_release_compile_flags(id, flags)
 
     case(id_intel_classic_mac)
         flags = &
+            flag_intel_opt//&
             flag_intel_fp//&
             flag_intel_align//&
             flag_intel_limit//&
@@ -300,7 +321,8 @@ subroutine get_release_compile_flags(id, flags)
 
     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//&
@@ -310,6 +332,7 @@ subroutine get_release_compile_flags(id, flags)
 
     case(id_intel_llvm_nix)
         flags = &
+            flag_intel_opt//&
             flag_intel_fp//&
             flag_intel_align//&
             flag_intel_limit//&
@@ -320,6 +343,7 @@ subroutine get_release_compile_flags(id, flags)
 
     case(id_intel_llvm_windows)
         flags = &
+            flag_intel_opt_win//&
             flag_intel_fp_win//&
             flag_intel_align_win//&
             flag_intel_limit_win//&
@@ -414,7 +438,7 @@ subroutine get_debug_compile_flags(id, flags)
     case(id_intel_llvm_nix)
         flags = &
             flag_intel_warn//&
-            flag_intel_check//&
+            flag_intel_llvm_check//&
             flag_intel_limit//&
             flag_intel_debug//&
             flag_intel_byterecl//&
@@ -1217,6 +1241,158 @@ pure function debug_archiver(self) result(repr)
     repr = 'ar="'//self%ar//'"'
 end function debug_archiver
 
+!> Check that two archiver_t objects are equal
+logical function ar_is_same(this,that)
+    class(archiver_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    ar_is_same = .false.
+
+    select type (other=>that)
+       type is (archiver_t)
+
+          if (.not.(this%ar==other%ar)) return
+          if (.not.(this%use_response_file.eqv.other%use_response_file)) return
+          if (.not.(this%echo.eqv.other%echo)) return
+          if (.not.(this%verbose.eqv.other%verbose)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    ar_is_same = .true.
+
+end function ar_is_same
+
+!> Dump dependency to toml table
+subroutine dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(archiver_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    !> Path to archiver
+    call set_string(table, "ar", self%ar, error, 'archiver_t')
+    if (allocated(error)) return
+    call set_value(table, "use-response-file", self%use_response_file, error, 'archiver_t')
+    if (allocated(error)) return
+    call set_value(table, "echo", self%echo, error, 'archiver_t')
+    if (allocated(error)) return
+    call set_value(table, "verbose", self%verbose, error, 'archiver_t')
+    if (allocated(error)) return
+
+end subroutine dump_to_toml
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(archiver_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call get_value(table, "ar", self%ar)
+
+    call get_value(table, "use-response-file", self%use_response_file, error, 'archiver_t')
+    if (allocated(error)) return
+    call get_value(table, "echo", self%echo, error, 'archiver_t')
+    if (allocated(error)) return
+    call get_value(table, "verbose", self%verbose, error, 'archiver_t')
+    if (allocated(error)) return
+
+end subroutine load_from_toml
+
+!> Check that two compiler_t objects are equal
+logical function compiler_is_same(this,that)
+    class(compiler_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    compiler_is_same = .false.
+
+    select type (other=>that)
+       type is (compiler_t)
+
+          if (.not.(this%id==other%id)) return
+          if (.not.(this%fc==other%fc)) return
+          if (.not.(this%cc==other%cc)) return
+          if (.not.(this%cxx==other%cxx)) return
+          if (.not.(this%echo.eqv.other%echo)) return
+          if (.not.(this%verbose.eqv.other%verbose)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    compiler_is_same = .true.
+
+end function compiler_is_same
+
+!> Dump dependency to toml table
+subroutine compiler_dump(self, table, error)
+
+    !> Instance of the serializable object
+    class(compiler_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr
+
+    call set_value(table, "id", self%id, error, 'compiler_t')
+    if (allocated(error)) return
+    call set_string(table, "fc", self%fc, error, 'compiler_t')
+    if (allocated(error)) return
+    call set_string(table, "cc", self%cc, error, 'compiler_t')
+    if (allocated(error)) return
+    call set_string(table, "cxx", self%cxx, error, 'compiler_t')
+    if (allocated(error)) return
+    call set_value(table, "echo", self%echo, error, 'compiler_t')
+    if (allocated(error)) return
+    call set_value(table, "verbose", self%verbose, error, 'compiler_t')
+    if (allocated(error)) return
+
+end subroutine compiler_dump
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine compiler_load(self, table, error)
+
+    !> Instance of the serializable object
+    class(compiler_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call get_value(table, "id", self%id, error, 'compiler_t')
+    if (allocated(error)) return
+    call get_value(table, "fc", self%fc)
+    call get_value(table, "cc", self%cc)
+    call get_value(table, "cxx", self%cxx)
+    call get_value(table, "echo", self%echo, error, 'compiler_t')
+    if (allocated(error)) return
+    call get_value(table, "verbose", self%verbose, error, 'compiler_t')
+    if (allocated(error)) return
+
+end subroutine compiler_load
+
 !> Return a compiler name string
 pure function compiler_name(self) result(name)
    !> Instance of the compiler object
diff --git a/src/fpm_environment.f90 b/src/fpm_environment.f90
index 7e8aa2317d..aba65e77bd 100644
--- a/src/fpm_environment.f90
+++ b/src/fpm_environment.f90
@@ -15,6 +15,7 @@ module fpm_environment
     public :: get_command_arguments_quoted
     public :: separator
 
+                        public :: OS_NAME
     integer, parameter, public :: OS_UNKNOWN = 0
     integer, parameter, public :: OS_LINUX   = 1
     integer, parameter, public :: OS_MACOS   = 2
@@ -24,6 +25,25 @@ module fpm_environment
     integer, parameter, public :: OS_FREEBSD = 6
     integer, parameter, public :: OS_OPENBSD = 7
 contains
+
+    !> Return string describing the OS type flag
+    pure function OS_NAME(os)
+        integer, intent(in) :: os
+        character(len=:), allocatable :: OS_NAME
+
+        select case (os)
+            case (OS_LINUX);   OS_NAME =  "Linux"
+            case (OS_MACOS);   OS_NAME =  "macOS"
+            case (OS_WINDOWS); OS_NAME =  "Windows"
+            case (OS_CYGWIN);  OS_NAME =  "Cygwin"
+            case (OS_SOLARIS); OS_NAME =  "Solaris"
+            case (OS_FREEBSD); OS_NAME =  "FreeBSD"
+            case (OS_OPENBSD); OS_NAME =  "OpenBSD"
+            case (OS_UNKNOWN); OS_NAME =  "Unknown"
+            case default     ; OS_NAME =  "UNKNOWN"
+        end select
+    end function OS_NAME
+
     !> Determine the OS type
     integer function get_os_type() result(r)
         !!
@@ -36,11 +56,11 @@ integer function get_os_type() result(r)
         !! found on specific system types only.
         !!
         !! Returns OS_UNKNOWN if the operating system cannot be determined.
-        character(len=32) :: val
-        integer           :: length, rc
-        logical           :: file_exists
-        logical, save     :: first_run = .true.
-        integer, save     :: ret = OS_UNKNOWN
+        character(len=255) :: val
+        integer            :: length, rc
+        logical            :: file_exists
+        logical, save      :: first_run = .true.
+        integer, save      :: ret = OS_UNKNOWN
         !$omp threadprivate(ret, first_run)
 
         if (.not. first_run) then
diff --git a/src/fpm_filesystem.F90 b/src/fpm_filesystem.F90
index 177ee85fea..6d65154df1 100644
--- a/src/fpm_filesystem.F90
+++ b/src/fpm_filesystem.F90
@@ -2,11 +2,12 @@
 !!
 module fpm_filesystem
     use,intrinsic :: iso_fortran_env, only : stdin=>input_unit, stdout=>output_unit, stderr=>error_unit
+    use,intrinsic :: iso_c_binding, only: c_new_line
     use fpm_environment, only: get_os_type, &
                                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, dilate, str_begins_with_str
+    use fpm_strings, only: f_string, replace, string_t, split, split_first_last, 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
@@ -50,6 +51,8 @@ end function c_is_dir
     end interface
 #endif
 
+    character(*), parameter :: eol = new_line('a')    !! End of line
+
 contains
 
 !> Extract filename from path with/without suffix
@@ -302,37 +305,71 @@ integer function number_of_rows(s) result(nrows)
 end function number_of_rows
 
 !> read lines into an array of TYPE(STRING_T) variables expanding tabs
-function read_lines_expanded(fh) result(lines)
-    integer, intent(in) :: fh
+function read_lines_expanded(filename) result(lines)
+    character(len=*), intent(in) :: filename
     type(string_t), allocatable :: lines(:)
 
     integer :: i
-    integer :: iostat
-    character(len=:),allocatable :: line_buffer_read
+    character(len=:), allocatable :: content
+    integer, allocatable :: first(:), last(:)
+
+    content = read_text_file(filename)
+    if (len(content) == 0) then
+        allocate (lines(0))
+        return
+    end if
+
+    call split_first_last(content, eol, first, last)  ! TODO: \r (< macOS X), \n (>=macOS X/Linux/Unix), \r\n (Windows)
 
-    allocate(lines(number_of_rows(fh)))
-    do i = 1, size(lines)
-        call getline(fh, line_buffer_read, iostat)
-        lines(i)%s = dilate(line_buffer_read)
+    ! allocate lines from file content string
+    allocate (lines(size(first)))
+    do i = 1, size(first)
+        allocate(lines(i)%s, source=dilate(content(first(i):last(i))))
     end do
 
 end function read_lines_expanded
 
 !> read lines into an array of TYPE(STRING_T) variables
-function read_lines(fh) result(lines)
-    integer, intent(in) :: fh
+function read_lines(filename) result(lines)
+    character(len=*), intent(in) :: filename
     type(string_t), allocatable :: lines(:)
 
     integer :: i
-    integer :: iostat
+    character(len=:), allocatable :: content
+    integer, allocatable :: first(:), last(:)
 
-    allocate(lines(number_of_rows(fh)))
-    do i = 1, size(lines)
-        call getline(fh, lines(i)%s, iostat)
+    content = read_text_file(filename)
+    if (len(content) == 0) then
+        allocate (lines(0))
+        return
+    end if
+
+    call split_first_last(content, eol, first, last)  ! TODO: \r (< macOS X), \n (>=macOS X/Linux/Unix), \r\n (Windows)
+
+    ! allocate lines from file content string
+    allocate (lines(size(first)))
+    do i = 1, size(first)
+        allocate(lines(i)%s, source=content(first(i):last(i)))
     end do
 
 end function read_lines
 
+!> read text file into a string
+function read_text_file(filename) result(string)
+    character(len=*), intent(in) :: filename
+    character(len=:), allocatable :: string
+    integer :: fh, length
+
+    open (newunit=fh, file=filename, status='old', action='read', &
+            access='stream', form='unformatted')
+    inquire (fh, size=length)
+    allocate (character(len=length) :: string)
+    if (length == 0) return
+    read (fh) string
+    close (fh)
+
+end function read_text_file
+
 !> Create a directory. Create subdirectories as needed
 subroutine mkdir(dir, echo)
     character(len=*), intent(in) :: dir
@@ -480,9 +517,8 @@ recursive subroutine list_files(dir, files, recurse)
         call fpm_stop(2,'*list_files*:directory listing failed')
     end if
 
-    open (newunit=fh, file=temp_file, status='old')
-    files = read_lines(fh)
-    close(fh,status="delete")
+    files = read_lines(temp_file)
+    call delete_file(temp_file)
 
     do i=1,size(files)
         files(i)%s = join_path(dir,files(i)%s)
@@ -654,7 +690,7 @@ end function unix_path
 !!    integer :: iostat
 !!    character(len=:),allocatable :: line, iomsg
 !!       open(unit=stdin,pad='yes')
-!!       INFINITE: do 
+!!       INFINITE: do
 !!          call getline(stdin,line,iostat,iomsg)
 !!          if(iostat /= 0) exit INFINITE
 !!          write(*,'(a)')'['//line//']'
@@ -678,7 +714,7 @@ subroutine getline(unit, line, iostat, iomsg)
     !> Error message
     character(len=:), allocatable, optional :: iomsg
 
-    integer, parameter :: BUFFER_SIZE = 32768
+    integer, parameter :: BUFFER_SIZE = 1024
     character(len=BUFFER_SIZE)       :: buffer
     character(len=256)               :: msg
     integer :: size
diff --git a/src/fpm_meta.f90 b/src/fpm_meta.f90
index f86e3a6b27..3265b26e47 100644
--- a/src/fpm_meta.f90
+++ b/src/fpm_meta.f90
@@ -3,21 +3,22 @@
 !> 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   
+!>
+!>### 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_strings, only: string_t, len_trim, remove_newline_characters, str_begins_with_str, &
+                       str_ends_with
 use fpm_error, only: error_t, fatal_error, syntax_error, fpm_stop
 use fpm_compiler
 use fpm_model
@@ -29,6 +30,8 @@ module fpm_meta
 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 shlex_module, only: shlex_split => split
+use regex_module, only: regex
 use iso_fortran_env, only: stdout => output_unit
 
 implicit none
@@ -106,6 +109,8 @@ module fpm_meta
 integer, parameter, private :: LANG_C       = 2
 integer, parameter, private :: LANG_CXX     = 3
 
+character(*), parameter :: LANG_NAME(*) = [character(7) :: 'Fortran','C','C++']
+
 contains
 
 !> Return a name for the MPI library
@@ -293,11 +298,8 @@ subroutine resolve_cmd(self,settings,error)
         select type (cmd=>settings)
            class is (fpm_run_settings) ! includes fpm_test_settings
 
-              if (.not.allocated(cmd%runner)) then
-                  cmd%runner = self%run_command%s
-              else
-                  cmd%runner = self%run_command%s//' '//cmd%runner
-              end if
+              ! 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
 
@@ -416,6 +418,15 @@ subroutine add_metapackage_model(model,package,settings,name,error)
     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
@@ -428,10 +439,8 @@ subroutine resolve_metapackage_model(model,package,settings,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
+    if (model%compiler%is_unknown()) &
+    write(stdout,'(a)') '<WARNING> compiler not initialized: metapackages may not be available'
 
     ! OpenMP
     if (package%meta%openmp%on) then
@@ -628,7 +637,13 @@ logical function msmpi_init(this,compiler,error) result(found)
             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
+        ! Third attempt for bash-style shell
+        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 fourth 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%...'
 
@@ -641,7 +656,7 @@ logical function msmpi_init(this,compiler,error) result(found)
 
         endif
 
-        if (allocated(error) .or. .not.exists(bindir)) then
+        if (allocated(error)) 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
@@ -859,7 +874,7 @@ subroutine get_mpi_runner(command,verbose,error)
 
     ! Try several commands
     do itri=1,size(try)
-       call find_command_location(trim(try(itri)),command%s,verbose=.true.,error=error)
+       call find_command_location(trim(try(itri)),command%s,verbose=verbose,error=error)
        if (allocated(error)) cycle
 
        ! Success!
@@ -971,33 +986,31 @@ subroutine init_mpi_from_wrappers(this,compiler,mpilib,fort_wrapper,c_wrapper,cx
     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)
+    this%link_flags = mpi_wrapper_query(mpilib,fort_wrapper,'link',verbose,error)
+    if (allocated(error)) return
 
-        ! 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)
+    ! Remove useless/dangerous flags
+    call filter_link_arguments(compiler,this%link_flags)
 
-        if (allocated(error)) return
-        this%has_link_flags = len_trim(this%link_flags)>0
-    endif
+    this%has_link_flags = len_trim(this%link_flags)>0
 
     ! 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)
+    call set_language_flags(compiler,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)
+    call set_language_flags(compiler,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)
+    call set_language_flags(compiler,mpilib,cxx_wrapper,this%has_cxx_flags,this%cxxflags,verbose,error)
     if (allocated(error)) return
 
     ! Get library version
@@ -1009,13 +1022,13 @@ subroutine init_mpi_from_wrappers(this,compiler,mpilib,fort_wrapper,c_wrapper,cx
     end if
 
     !> Add default run command, if present
-    this%run_command = mpi_wrapper_query(mpilib,fort_wrapper,'runner',verbose,error)
-    if (allocated(error)) return
-    this%has_run_command = len_trim(this%run_command)>0
+    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)
+    subroutine set_language_flags(compiler,mpilib,wrapper,has_flags,flags,verbose,error)
+        type(compiler_t), intent(in) :: compiler
         integer, intent(in) :: mpilib
         type(string_t), intent(in) :: wrapper
         logical, intent(inout) :: has_flags
@@ -1035,6 +1048,8 @@ subroutine set_language_flags(mpilib,wrapper,has_flags,flags,verbose,error)
 
             if (verbose) print *, '+ MPI language flags from wrapper <',wrapper%s,'>: flags=',flags%s
 
+            call filter_build_arguments(compiler,flags)
+
         endif
 
     end subroutine set_language_flags
@@ -1049,13 +1064,16 @@ subroutine mpi_compiler_match(language,wrappers,compiler,which_one,mpilib,error)
     integer, intent(out) :: which_one, mpilib
     type(error_t), allocatable, intent(out) :: error
 
-    integer :: i
+    integer :: i, same_vendor, vendor_mpilib
     type(string_t) :: screen
     character(128) :: msg_out
     type(compiler_t) :: mpi_compiler
 
-    which_one = 0
-    mpilib = MPI_TYPE_NONE
+    which_one   = 0
+    same_vendor = 0
+    mpilib      = MPI_TYPE_NONE
+
+    if (verbose) print *, '+ Trying to match available ',LANG_NAME(language),' MPI wrappers to ',compiler%fc,'...'
 
     do i=1,size(wrappers)
 
@@ -1064,17 +1082,18 @@ subroutine mpi_compiler_match(language,wrappers,compiler,which_one,mpilib,error)
         screen = mpi_wrapper_query(mpilib,wrappers(i),'compiler',verbose=.false.,error=error)
         if (allocated(error)) return
 
+        if (verbose) print *, '  Wrapper ',wrappers(i)%s,' lib=',MPI_TYPE_NAME(mpilib),' uses ',screen%s
+
         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=.true.)
+               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
@@ -1088,8 +1107,20 @@ subroutine mpi_compiler_match(language,wrappers,compiler,which_one,mpilib,error)
                end if
         end select
 
+        ! Because the intel mpi library does not support llvm_ compiler wrappers yet,
+        ! we must check for that manually
+        if (is_intel_classic_option(language,same_vendor,screen,compiler,mpi_compiler)) then
+            same_vendor = i
+            vendor_mpilib = mpilib
+        end if
     end do
 
+    ! Intel compiler: if an exact match is not found, attempt closest wrapper
+    if (which_one==0 .and. same_vendor>0) then
+        which_one = same_vendor
+        mpilib    = vendor_mpilib
+    end if
+
     ! 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))
@@ -1097,6 +1128,28 @@ subroutine mpi_compiler_match(language,wrappers,compiler,which_one,mpilib,error)
 
 end subroutine mpi_compiler_match
 
+!> Because the Intel mpi library does not support llvm_ compiler wrappers yet,
+!> we must save the Intel-classic option and later manually replace it
+logical function is_intel_classic_option(language,same_vendor_ID,screen_out,compiler,mpi_compiler)
+    integer, intent(in) :: language,same_vendor_ID
+    type(string_t), intent(in) :: screen_out
+    type(compiler_t), intent(in) :: compiler,mpi_compiler
+
+    if (same_vendor_ID/=0) then
+        is_intel_classic_option = .false.
+    else
+        select case (language)
+           case (LANG_FORTRAN)
+               is_intel_classic_option = mpi_compiler%is_intel() .and. compiler%is_intel()
+           case (LANG_C)
+               is_intel_classic_option = screen_out%s=='icc' .and. compiler%cc=='icx'
+           case (LANG_CXX)
+               is_intel_classic_option = screen_out%s=='icpc' .and. compiler%cc=='icpx'
+        end select
+    end if
+
+end function is_intel_classic_option
+
 !> Return library version from the MPI wrapper command
 type(version_t) function mpi_version_get(mpilib,wrapper,error)
    integer, intent(in) :: mpilib
@@ -1389,6 +1442,7 @@ type(string_t) function mpi_wrapper_query(mpilib,wrapper,command,verbose,error)
            end if
 
            ! Take out the first command from the whole line
+           call remove_newline_characters(screen)
            call split(screen%s,tokens,delimiters=' ')
            screen%s = trim(adjustl(tokens(1)))
 
@@ -1435,6 +1489,7 @@ type(string_t) function mpi_wrapper_query(mpilib,wrapper,command,verbose,error)
            select case (mpilib)
               case (MPI_TYPE_OPENMPI); cmdstr = string_t('--showme:link')
               case (MPI_TYPE_MPICH);   cmdstr = string_t('-link-info')
+              case (MPI_TYPE_INTEL);   cmdstr = string_t('-show')
               case default
                  call fatal_error(error,unsupported_msg)
                  return
@@ -1452,7 +1507,7 @@ type(string_t) function mpi_wrapper_query(mpilib,wrapper,command,verbose,error)
            select case (mpilib)
               case (MPI_TYPE_OPENMPI)
                  call remove_newline_characters(screen)
-              case (MPI_TYPE_MPICH)
+              case (MPI_TYPE_MPICH,MPI_TYPE_INTEL)
                  ! MPICH reports the full command including the compiler name. Remove it if so
                  call remove_newline_characters(screen)
                  call split(screen%s,tokens)
@@ -1592,4 +1647,123 @@ type(string_t) function mpi_wrapper_query(mpilib,wrapper,command,verbose,error)
 
 end function mpi_wrapper_query
 
+!> Check if input is a useful linker argument
+logical function is_link_argument(compiler,string)
+   type(compiler_t), intent(in) :: compiler
+   character(*), intent(in) :: string
+
+   select case (compiler%id)
+      case (id_intel_classic_windows,id_intel_llvm_windows)
+          is_link_argument = string=='/link' &
+                             .or. str_begins_with_str(string,'/LIBPATH')&
+                             .or. str_ends_with(string,'.lib') ! always .lib whether static or dynamic
+      case default
+
+          ! fix OpenMPI's Fortran wrapper bug (https://github.com/open-mpi/ompi/issues/11636) here
+          is_link_argument = (    str_begins_with_str(string,'-L') &
+                             .or. str_begins_with_str(string,'-l') &
+                             .or. str_begins_with_str(string,'-Xlinker') &
+                             .or. string=='-pthread' &
+                             .or. (str_begins_with_str(string,'-W') .and. &
+                                   (string/='-Wall') .and. (.not.str_begins_with_str(string,'-Werror'))) ) &
+                             .and. .not. ( &
+                                 (get_os_type()==OS_MACOS .and. index(string,'-commons,use_dylibs')>0) )
+   end select
+
+end function is_link_argument
+
+!> From build, remove optimization and other unnecessary flags
+subroutine filter_build_arguments(compiler,command)
+    type(compiler_t), intent(in) :: compiler
+    type(string_t), intent(inout) :: command
+    character(len=:), allocatable :: tokens(:)
+
+    integer :: i,n,re_i,re_l
+    logical, allocatable :: keep(:)
+    logical :: keep_next
+    character(len=:), allocatable :: module_flag,include_flag
+
+    if (len_trim(command)<=0) return
+
+    ! Split command into arguments
+    tokens = shlex_split(command%s)
+
+    module_flag  = get_module_flag(compiler,"")
+    include_flag = get_include_flag(compiler,"")
+
+    n = size(tokens)
+    allocate(keep(n),source=.false.)
+    keep_next = .false.
+
+    do i=1,n
+
+        if (get_os_type()==OS_MACOS .and. index(tokens(i),'-commons,use_dylibs')>0) then
+            keep(i) = .false.
+            keep_next = .false.
+        elseif (str_begins_with_str(tokens(i),'-D') .or. &
+                str_begins_with_str(tokens(i),'-f') .or. &
+                str_begins_with_str(tokens(i),'-I') .or. &
+                str_begins_with_str(tokens(i),module_flag) .or. &
+                str_begins_with_str(tokens(i),include_flag) .or. &
+                tokens(i)=='-pthread' .or. &
+                (str_begins_with_str(tokens(i),'-W') .and. tokens(i)/='-Wall' .and. .not.str_begins_with_str(tokens(i),'-Werror')) &
+                ) then
+                   keep(i) = .true.
+                   if (tokens(i)==module_flag .or. tokens(i)==include_flag .or. tokens(i)=='-I') keep_next = .true.
+        elseif (keep_next) then
+            keep(i) = .true.
+            keep_next = .false.
+        end if
+    end do
+
+    ! Backfill
+    command = string_t("")
+    do i=1,n
+        if (.not.keep(i)) cycle
+
+        command%s = command%s//' '//trim(tokens(i))
+    end do
+
+
+end subroutine filter_build_arguments
+
+!> From the linker flags, remove optimization and other unnecessary flags
+subroutine filter_link_arguments(compiler,command)
+    type(compiler_t), intent(in) :: compiler
+    type(string_t), intent(inout) :: command
+    character(len=:), allocatable :: tokens(:)
+
+    integer :: i,n
+    logical, allocatable :: keep(:)
+    logical :: keep_next
+
+    if (len_trim(command)<=0) return
+
+    ! Split command into arguments
+    tokens = shlex_split(command%s)
+
+    n = size(tokens)
+    allocate(keep(n),source=.false.)
+    keep_next = .false.
+
+    do i=1,n
+       if (is_link_argument(compiler,tokens(i))) then
+           keep(i) = .true.
+           if (tokens(i)=='-L' .or. tokens(i)=='-Xlinker') keep_next = .true.
+       elseif (keep_next) then
+           keep(i) = .true.
+           keep_next = .false.
+       end if
+    end do
+
+    ! Backfill
+    command = string_t("")
+    do i=1,n
+        if (.not.keep(i)) cycle
+        command%s = command%s//' '//trim(tokens(i))
+    end do
+
+end subroutine filter_link_arguments
+
+
 end module fpm_meta
diff --git a/src/fpm_model.f90 b/src/fpm_model.f90
index dba15a8161..8663f33b6e 100644
--- a/src/fpm_model.f90
+++ b/src/fpm_model.f90
@@ -38,11 +38,15 @@ module fpm_model
 use iso_fortran_env, only: int64
 use fpm_compiler, only: compiler_t, archiver_t, debug
 use fpm_dependency, only: dependency_tree_t
-use fpm_strings, only: string_t, str, len_trim
+use fpm_strings, only: string_t, str, len_trim, upper, operator(==)
+use fpm_toml, only: serializable_t, toml_table, toml_stat, set_value, set_list, get_value, &
+                    & get_list, add_table, toml_key, add_array, set_string
+use fpm_error, only: error_t, fatal_error
+use fpm_manifest_preprocess, only: preprocess_config_t
 implicit none
 
 private
-public :: fpm_model_t, srcfile_t, show_model, fortran_features_t
+public :: fpm_model_t, srcfile_t, show_model, fortran_features_t, package_t
 
 public :: FPM_UNIT_UNKNOWN, FPM_UNIT_PROGRAM, FPM_UNIT_MODULE, &
           FPM_UNIT_SUBMODULE, FPM_UNIT_SUBPROGRAM, FPM_UNIT_CSOURCE, &
@@ -80,7 +84,7 @@ module fpm_model
 integer, parameter :: FPM_SCOPE_EXAMPLE = 5
 
 !> Enabled Fortran language features
-type :: fortran_features_t
+type, extends(serializable_t) :: fortran_features_t
 
     !> Use default implicit typing
     logical :: implicit_typing = .false.
@@ -90,10 +94,18 @@ module fpm_model
 
     !> Form to use for all Fortran sources
     character(:), allocatable :: source_form
+
+    contains
+
+        !> Serialization interface
+        procedure :: serializable_is_same => fft_is_same
+        procedure :: dump_to_toml   => fft_dump_to_toml
+        procedure :: load_from_toml => fft_load_from_toml
+
 end type fortran_features_t
 
 !> Type for describing a source file
-type srcfile_t
+type, extends(serializable_t) :: srcfile_t
     !> File path relative to cwd
     character(:), allocatable :: file_name
 
@@ -124,11 +136,18 @@ module fpm_model
     !> Current hash
     integer(int64) :: digest
 
+    contains
+
+        !> Serialization interface
+        procedure :: serializable_is_same => srcfile_is_same
+        procedure :: dump_to_toml   => srcfile_dump_to_toml
+        procedure :: load_from_toml => srcfile_load_from_toml
+
 end type srcfile_t
 
 
 !> Type for describing a single package
-type package_t
+type, extends(serializable_t) :: package_t
 
     !> Name of package
     character(:), allocatable :: name
@@ -137,13 +156,13 @@ module fpm_model
     type(srcfile_t), allocatable :: sources(:)
 
     !> List of macros.
-    type(string_t), allocatable :: macros(:)
+    type(preprocess_config_t) :: preprocess
 
     !> Package version number.
     character(:), allocatable :: version
 
     !> Module naming conventions
-    logical :: enforce_module_names
+    logical :: enforce_module_names = .false.
 
     !> Prefix for all module names
     type(string_t) :: module_prefix
@@ -151,12 +170,19 @@ module fpm_model
     !> Language features
     type(fortran_features_t) :: features
 
+    contains
+
+        !> Serialization interface
+        procedure :: serializable_is_same => package_is_same
+        procedure :: dump_to_toml   => package_dump_to_toml
+        procedure :: load_from_toml => package_load_from_toml
+
 end type package_t
 
 
 !> Type describing everything required to build
 !>  the root package and its dependencies.
-type :: fpm_model_t
+type, extends(serializable_t) :: fpm_model_t
 
     !> Name of root package
     character(:), allocatable :: package_name
@@ -206,6 +232,13 @@ module fpm_model
     !> Prefix for all module names
     type(string_t) :: module_prefix
 
+    contains
+
+        !> Serialization interface
+        procedure :: serializable_is_same => model_is_same
+        procedure :: dump_to_toml   => model_dump_to_toml
+        procedure :: load_from_toml => model_load_from_toml
+
 end type fpm_model_t
 
 contains
@@ -249,23 +282,7 @@ function info_srcfile(source) result(s)
     !    character(:), allocatable :: exe_name
     s = s // ', exe_name="' // source%exe_name // '"'
     !    integer :: unit_scope = FPM_SCOPE_UNKNOWN
-    s = s // ", unit_scope="
-    select case(source%unit_scope)
-    case (FPM_SCOPE_UNKNOWN)
-        s = s // "FPM_SCOPE_UNKNOWN"
-    case (FPM_SCOPE_LIB)
-        s = s // "FPM_SCOPE_LIB"
-    case (FPM_SCOPE_DEP)
-        s = s // "FPM_SCOPE_DEP"
-    case (FPM_SCOPE_APP)
-        s = s // "FPM_SCOPE_APP"
-    case (FPM_SCOPE_TEST)
-        s = s // "FPM_SCOPE_TEST"
-    case (FPM_SCOPE_EXAMPLE)
-        s = s // "FPM_SCOPE_EXAMPLE"
-    case default
-        s = s // "INVALID"
-    end select
+    s = s // ', unit_scope="' // FPM_SCOPE_NAME(source%unit_scope) // '"'
     !    type(string_t), allocatable :: modules_provided(:)
     s = s // ", modules_provided=["
     do i = 1, size(source%modules_provided)
@@ -280,27 +297,7 @@ function info_srcfile(source) result(s)
     end do
     s = s // "]"
     !    integer :: unit_type = FPM_UNIT_UNKNOWN
-    s = s // ", unit_type="
-    select case(source%unit_type)
-    case (FPM_UNIT_UNKNOWN)
-        s = s // "FPM_UNIT_UNKNOWN"
-    case (FPM_UNIT_PROGRAM)
-        s = s // "FPM_UNIT_PROGRAM"
-    case (FPM_UNIT_MODULE)
-        s = s // "FPM_UNIT_MODULE"
-    case (FPM_UNIT_SUBMODULE)
-        s = s // "FPM_UNIT_SUBMODULE"
-    case (FPM_UNIT_SUBPROGRAM)
-        s = s // "FPM_UNIT_SUBPROGRAM"
-    case (FPM_UNIT_CSOURCE)
-        s = s // "FPM_UNIT_CSOURCE"
-    case (FPM_UNIT_CPPSOURCE)
-        s = s // "FPM_UNIT_CPPSOURCE"
-    case (FPM_UNIT_CHEADER)
-        s = s // "FPM_UNIT_CHEADER"
-    case default
-        s = s // "INVALID"
-    end select
+    s = s // ', unit_type="' // FPM_UNIT_NAME(source%unit_type) // '"'
     !    type(string_t), allocatable :: modules_used(:)
     s = s // ", modules_used=["
     do i = 1, size(source%modules_used)
@@ -396,4 +393,691 @@ subroutine show_model(model)
     print *, info_model(model)
 end subroutine show_model
 
+!> Return the character name of a scope flag
+function FPM_SCOPE_NAME(flag) result(name)
+    integer, intent(in) :: flag
+    character(len=:), allocatable :: name
+
+    select case (flag)
+       case (FPM_SCOPE_UNKNOWN); name = "FPM_SCOPE_UNKNOWN"
+       case (FPM_SCOPE_LIB);     name = "FPM_SCOPE_LIB"
+       case (FPM_SCOPE_DEP);     name = "FPM_SCOPE_DEP"
+       case (FPM_SCOPE_APP);     name = "FPM_SCOPE_APP"
+       case (FPM_SCOPE_TEST);    name = "FPM_SCOPE_TEST"
+       case (FPM_SCOPE_EXAMPLE); name = "FPM_SCOPE_EXAMPLE"
+       case default;             name = "INVALID"
+    end select
+end function FPM_SCOPE_NAME
+
+!> Parse git FPM_SCOPE identifier from a string
+integer function parse_scope(name) result(scope)
+    character(len=*), intent(in) :: name
+
+    character(len=len(name)) :: uppercase
+
+    !> Make it Case insensitive
+    uppercase = upper(name)
+
+    select case (trim(uppercase))
+       case ("FPM_SCOPE_UNKNOWN"); scope = FPM_SCOPE_UNKNOWN
+       case ("FPM_SCOPE_LIB");     scope = FPM_SCOPE_LIB
+       case ("FPM_SCOPE_DEP");     scope = FPM_SCOPE_DEP
+       case ("FPM_SCOPE_APP");     scope = FPM_SCOPE_APP
+       case ("FPM_SCOPE_TEST");    scope = FPM_SCOPE_TEST
+       case ("FPM_SCOPE_EXAMPLE"); scope = FPM_SCOPE_EXAMPLE
+       case default;               scope = -9999
+    end select
+
+end function parse_scope
+
+!> Return the character name of a unit flag
+function FPM_UNIT_NAME(flag) result(name)
+    integer, intent(in) :: flag
+    character(len=:), allocatable :: name
+
+    select case (flag)
+       case (FPM_UNIT_UNKNOWN);    name = "FPM_UNIT_UNKNOWN"
+       case (FPM_UNIT_PROGRAM);    name = "FPM_UNIT_PROGRAM"
+       case (FPM_UNIT_MODULE);     name = "FPM_UNIT_MODULE"
+       case (FPM_UNIT_SUBMODULE);  name = "FPM_UNIT_SUBMODULE"
+       case (FPM_UNIT_SUBPROGRAM); name = "FPM_UNIT_SUBPROGRAM"
+       case (FPM_UNIT_CSOURCE);    name = "FPM_UNIT_CSOURCE"
+       case (FPM_UNIT_CPPSOURCE);  name = "FPM_UNIT_CPPSOURCE"
+       case (FPM_UNIT_CHEADER);    name = "FPM_UNIT_CHEADER"
+       case default;               name = "INVALID"
+    end select
+end function FPM_UNIT_NAME
+
+!> Parse git FPM_UNIT identifier from a string
+integer function parse_unit(name) result(unit)
+    character(len=*), intent(in) :: name
+
+    character(len=len(name)) :: uppercase
+
+    !> Make it Case insensitive
+    uppercase = upper(name)
+
+    select case (trim(uppercase))
+       case ("FPM_UNIT_UNKNOWN");    unit = FPM_UNIT_UNKNOWN
+       case ("FPM_UNIT_PROGRAM");    unit = FPM_UNIT_PROGRAM
+       case ("FPM_UNIT_MODULE");     unit = FPM_UNIT_MODULE
+       case ("FPM_UNIT_SUBMODULE");  unit = FPM_UNIT_SUBMODULE
+       case ("FPM_UNIT_SUBPROGRAM"); unit = FPM_UNIT_SUBPROGRAM
+       case ("FPM_UNIT_CSOURCE");    unit = FPM_UNIT_CSOURCE
+       case ("FPM_UNIT_CPPSOURCE");  unit = FPM_UNIT_CPPSOURCE
+       case ("FPM_UNIT_CHEADER");    unit = FPM_UNIT_CHEADER
+       case default;                 unit = -9999
+    end select
+
+end function parse_unit
+
+!> Check that two source files are equal
+logical function srcfile_is_same(this,that)
+    class(srcfile_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    srcfile_is_same = .false.
+
+    select type (other=>that)
+       type is (srcfile_t)
+
+          if (.not.(this%file_name==other%file_name)) return
+          if (.not.(this%exe_name==other%exe_name)) return
+          if (.not.(this%unit_scope==other%unit_scope)) return
+          if (.not.(this%modules_provided==other%modules_provided)) return
+          if (.not.(this%unit_type==other%unit_type)) return
+          if (.not.(this%parent_modules==other%parent_modules)) return
+          if (.not.(this%modules_used==other%modules_used)) return
+          if (.not.(this%include_dependencies==other%include_dependencies)) return
+          if (.not.(this%link_libraries==other%link_libraries)) return
+          if (.not.(this%digest==other%digest)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    srcfile_is_same = .true.
+
+end function srcfile_is_same
+
+!> Dump dependency to toml table
+subroutine srcfile_dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(srcfile_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr
+
+    call set_string(table, "file-name", self%file_name, error, 'srcfile_t')
+    if (allocated(error)) return
+    call set_string(table, "exe-name", self%exe_name, error, 'srcfile_t')
+    if (allocated(error)) return
+    call set_value(table, "digest", self%digest, error, 'srcfile_t')
+    if (allocated(error)) return
+
+    ! unit_scope and unit_type are saved as strings so the output is independent
+    ! of the internal representation
+    call set_string(table,"unit-scope",FPM_SCOPE_NAME(self%unit_scope), error, 'srcfile_t')
+    if (allocated(error)) return
+    call set_string(table,"unit-type",FPM_UNIT_NAME(self%unit_type), error, 'srcfile_t')
+    if (allocated(error)) return
+    call set_list(table, "modules-provided",self%modules_provided, error)
+    if (allocated(error)) return
+    call set_list(table, "parent-modules",self%parent_modules, error)
+    if (allocated(error)) return
+    call set_list(table, "modules-used",self%modules_used, error)
+    if (allocated(error)) return
+    call set_list(table, "include-dependencies",self%include_dependencies, error)
+    if (allocated(error)) return
+    call set_list(table, "link-libraries",self%link_libraries, error)
+    if (allocated(error)) return
+
+end subroutine srcfile_dump_to_toml
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine srcfile_load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(srcfile_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    character(len=:), allocatable :: flag
+    integer :: ierr
+
+    call get_value(table, "file-name", self%file_name)
+    call get_value(table, "exe-name", self%exe_name)
+    call get_value(table, "digest", self%digest, error, 'srcfile_t')
+    if (allocated(error)) return
+
+    ! unit_scope and unit_type are saved as strings so the output is independent
+    ! of the internal representation
+    call get_value(table, "unit-scope", flag)
+    if (allocated(flag)) self%unit_scope = parse_scope(flag)
+    call get_value(table, "unit-type", flag)
+    if (allocated(flag)) self%unit_type = parse_unit(flag)
+
+    call get_list(table,"modules-provided",self%modules_provided, error)
+    if (allocated(error)) return
+
+    call get_list(table,"parent-modules",self%parent_modules, error)
+    if (allocated(error)) return
+
+    call get_list(table,"modules-used",self%modules_used, error)
+    if (allocated(error)) return
+
+    call get_list(table,"include-dependencies",self%include_dependencies, error)
+    if (allocated(error)) return
+
+    call get_list(table,"link-libraries",self%link_libraries, error)
+    if (allocated(error)) return
+
+end subroutine srcfile_load_from_toml
+
+!> Check that two fortran feature objects are equal
+logical function fft_is_same(this,that)
+    class(fortran_features_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    fft_is_same = .false.
+
+    select type (other=>that)
+       type is (fortran_features_t)
+
+           if (.not.(this%implicit_typing.eqv.other%implicit_typing)) return
+           if (.not.(this%implicit_external.eqv.other%implicit_external)) return
+           if (.not.(this%source_form==other%source_form)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    fft_is_same = .true.
+
+end function fft_is_same
+
+!> Dump fortran features to toml table
+subroutine fft_dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fortran_features_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    call set_value(table, "implicit-typing", self%implicit_typing, error, 'fortran_features_t')
+    if (allocated(error)) return
+    call set_value(table, "implicit-external", self%implicit_external, error, 'fortran_features_t')
+    if (allocated(error)) return
+    call set_string(table, "source-form", self%source_form, error, 'fortran_features_t')
+    if (allocated(error)) return
+
+end subroutine fft_dump_to_toml
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine fft_load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fortran_features_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr
+
+    call get_value(table, "implicit-typing", self%implicit_typing, error, 'fortran_features_t')
+    if (allocated(error)) return
+    call get_value(table, "implicit-external", self%implicit_external, error, 'fortran_features_t')
+    if (allocated(error)) return
+    ! Return unallocated value if not present
+    call get_value(table, "source-form", self%source_form)
+
+end subroutine fft_load_from_toml
+
+!> Check that two package objects are equal
+logical function package_is_same(this,that)
+    class(package_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    integer :: ii
+
+    package_is_same = .false.
+
+    select type (other=>that)
+       type is (package_t)
+
+           if (.not.(this%name==other%name)) return
+           if (.not.(allocated(this%sources).eqv.allocated(other%sources))) return
+           if (allocated(this%sources)) then
+              if (.not.(size(this%sources)==size(other%sources))) return
+              do ii = 1, size(this%sources)
+                  if (.not.(this%sources(ii)==other%sources(ii))) return
+              end do
+           end if
+
+           if (.not.(this%preprocess==other%preprocess)) return
+           if (.not.(this%version==other%version)) return
+
+           !> Module naming
+           if (.not.(this%enforce_module_names.eqv.other%enforce_module_names)) return
+           if (.not.(this%module_prefix==other%module_prefix)) return
+
+           !> Fortran features
+           if (.not.(this%features==other%features)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    package_is_same = .true.
+
+end function package_is_same
+
+!> Dump dependency to toml table
+subroutine package_dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(package_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr, ii
+    type(toml_table), pointer :: ptr,this_source
+    character(16) :: src_name
+
+    call set_string(table, "name", self%name, error, 'package_t')
+    if (allocated(error)) return
+
+    call set_string(table, "version", self%version, error, 'package_t')
+    if (allocated(error)) return
+
+    call set_value(table, "module-naming", self%enforce_module_names, error, 'package_t')
+    if (allocated(error)) return
+
+    call set_string(table, "module-prefix", self%module_prefix, error, 'package_t')
+    if (allocated(error)) return
+
+    !> Create a preprocessor table
+    call add_table(table, "preprocess", ptr, error, 'package_t')
+    if (allocated(error)) return
+    call self%preprocess%dump_to_toml(ptr, error)
+    if (allocated(error)) return
+
+    !> Create a fortran table
+    call add_table(table, "fortran", ptr, error, 'package_t')
+    if (allocated(error)) return
+    call self%features%dump_to_toml(ptr, error)
+    if (allocated(error)) return
+
+    !> Create a sources table
+    if (allocated(self%sources)) then
+
+        call add_table(table, "sources", ptr, error, 'package_t')
+        if (allocated(error)) return
+
+        do ii = 1, size(self%sources)
+
+            write(src_name,1) ii
+            call add_table(ptr, trim(src_name), this_source, error, 'package_t[source]')
+            if (allocated(error)) return
+            call self%sources(ii)%dump_to_toml(this_source,error)
+            if (allocated(error)) return
+
+        end do
+
+    end if
+
+    1 format('src_',i0)
+
+end subroutine package_dump_to_toml
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine package_load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(package_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr,ii,jj
+    type(toml_key), allocatable :: keys(:),src_keys(:)
+    type(toml_table), pointer :: ptr_sources,ptr,ptr_fortran,ptr_preprocess
+    type(error_t), allocatable :: new_error
+
+    call get_value(table, "name", self%name)
+    call get_value(table, "version", self%version)
+
+    call get_value(table, "module-naming", self%enforce_module_names, error, 'package_t')
+    if (allocated(error)) return
+
+    ! Return unallocated value if not present
+    call get_value(table, "module-prefix", self%module_prefix%s)
+
+    ! Sources
+    call table%get_keys(keys)
+
+    find_others: do ii = 1, size(keys)
+        select case (keys(ii)%key)
+           case ("fortran")
+
+               call get_value(table, keys(ii), ptr_fortran)
+               if (.not.associated(ptr_fortran)) then
+                  call fatal_error(error,'package_t: error retrieving fortran table from TOML table')
+                  return
+               end if
+
+               call self%features%load_from_toml(ptr_fortran,error)
+               if (allocated(error)) return
+
+           case ("preprocess")
+
+               call get_value(table, keys(ii), ptr_preprocess)
+               if (.not.associated(ptr_preprocess)) then
+                  call fatal_error(error,'package_t: error retrieving preprocess table from TOML table')
+                  return
+               end if
+
+               call self%preprocess%load_from_toml(ptr_preprocess,error)
+               if (allocated(error)) return
+
+           case ("sources")
+
+               call get_value(table, keys(ii), ptr_sources)
+               if (.not.associated(ptr_sources)) then
+                  call fatal_error(error,'package_t: error retrieving sources table from TOML table')
+                  return
+               end if
+
+               !> Read all dependencies
+               call ptr_sources%get_keys(src_keys)
+               allocate(self%sources(size(src_keys)))
+
+               do jj = 1, size(src_keys)
+                   call get_value(ptr_sources, src_keys(jj), ptr)
+                   call self%sources(jj)%load_from_toml(ptr, error)
+                   if (allocated(error)) return
+               end do
+
+           case default
+              cycle find_others
+        end select
+    end do find_others
+
+end subroutine package_load_from_toml
+
+
+!> Check that two model objects are equal
+logical function model_is_same(this,that)
+    class(fpm_model_t), intent(in) :: this
+    class(serializable_t), intent(in) :: that
+
+    type(fpm_model_t), pointer :: other
+
+    integer :: ii
+
+    model_is_same = .false.
+
+    select type (other=>that)
+       type is (fpm_model_t)
+
+           if (.not.(this%package_name==other%package_name)) return
+           if (.not.(allocated(this%packages).eqv.allocated(other%packages))) return
+           if (allocated(this%packages)) then
+               if (.not.(size(this%packages)==size(other%packages))) return
+               do ii = 1, size(this%packages)
+                   if (.not.(this%packages(ii)==other%packages(ii))) return
+               end do
+           end if
+
+           if (.not.(this%compiler==other%compiler)) return
+           if (.not.(this%archiver==other%archiver)) return
+           if (.not.(this%fortran_compile_flags==other%fortran_compile_flags)) return
+           if (.not.(this%c_compile_flags==other%c_compile_flags)) return
+           if (.not.(this%cxx_compile_flags==other%cxx_compile_flags)) return
+           if (.not.(this%link_flags==other%link_flags)) return
+           if (.not.(this%build_prefix==other%build_prefix)) return
+           if (.not.(this%include_dirs==other%include_dirs)) return
+           if (.not.(this%link_libraries==other%link_libraries)) return
+           if (.not.(this%external_modules==other%external_modules)) return
+           if (.not.(this%deps==other%deps)) return
+           if (.not.(this%include_tests.eqv.other%include_tests)) return
+           if (.not.(this%enforce_module_names.eqv.other%enforce_module_names)) return
+           if (.not.(this%module_prefix==other%module_prefix)) return
+
+       class default
+          ! Not the same type
+          return
+    end select
+
+    !> All checks passed!
+    model_is_same = .true.
+
+end function model_is_same
+
+!> Dump dependency to toml table
+subroutine model_dump_to_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fpm_model_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    integer :: ierr, ii
+    type(toml_table), pointer :: ptr,ptr_pkg
+    character(27) :: unnamed
+
+    call set_string(table, "package-name", self%package_name, error, 'fpm_model_t')
+    if (allocated(error)) return
+
+    call add_table(table, "compiler", ptr, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call self%compiler%dump_to_toml(ptr, error)
+    if (allocated(error)) return
+
+    call add_table(table, "archiver", ptr, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call self%archiver%dump_to_toml(ptr, error)
+    if (allocated(error)) return
+
+    call set_string(table, "fortran-flags", self%fortran_compile_flags, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_string(table, "c-flags", self%c_compile_flags, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_string(table, "cxx-flags", self%cxx_compile_flags, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_string(table, "link-flags", self%link_flags, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_string(table, "build-prefix", self%build_prefix, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_list(table, "include-dirs", self%include_dirs, error)
+    if (allocated(error)) return
+    call set_list(table, "link-libraries", self%link_libraries, error)
+    if (allocated(error)) return
+    call set_list(table, "external-modules", self%external_modules, error)
+    if (allocated(error)) return
+
+    call set_value(table, "include-tests", self%include_tests, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_value(table, "module-naming", self%enforce_module_names, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call set_string(table, "module-prefix", self%module_prefix, error, 'fpm_model_t')
+    if (allocated(error)) return
+
+    call add_table(table, "deps", ptr, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call self%deps%dump_to_toml(ptr, error)
+    if (allocated(error)) return
+
+    !> Array of packages (including the root package)
+    if (allocated(self%packages)) then
+
+           ! Create packages table
+           call add_table(table, "packages", ptr_pkg)
+           if (.not. associated(ptr_pkg)) then
+              call fatal_error(error, "fpm_model_t cannot create dependency table ")
+              return
+           end if
+
+           do ii = 1, size(self%packages)
+
+              associate (pkg => self%packages(ii))
+
+                 !> Because dependencies are named, fallback if this has no name
+                 !> So, serialization will work regardless of size(self%dep) == self%ndep
+                 if (len_trim(pkg%name)==0) then
+                    write(unnamed,1) ii
+                    call add_table(ptr_pkg, trim(unnamed), ptr, error, 'fpm_model_t[package]')
+                 else
+                    call add_table(ptr_pkg, pkg%name, ptr, error, 'fpm_model_t[package]')
+                 end if
+                 if (allocated(error)) return
+                 call pkg%dump_to_toml(ptr, error)
+                 if (allocated(error)) return
+
+              end associate
+
+           end do
+    end if
+
+    1 format('UNNAMED_PACKAGE_',i0)
+
+end subroutine model_dump_to_toml
+
+!> Read dependency from toml table (no checks made at this stage)
+subroutine model_load_from_toml(self, table, error)
+
+    !> Instance of the serializable object
+    class(fpm_model_t), intent(inout) :: self
+
+    !> Data structure
+    type(toml_table), intent(inout) :: table
+
+    !> Error handling
+    type(error_t), allocatable, intent(out) :: error
+
+    type(toml_key), allocatable :: keys(:),pkg_keys(:)
+    integer :: ierr, ii, jj
+    type(toml_table), pointer :: ptr,ptr_pkg
+
+    call table%get_keys(keys)
+
+    call get_value(table, "package-name", self%package_name)
+    call get_value(table, "fortran-flags", self%fortran_compile_flags)
+    call get_value(table, "c-flags", self%c_compile_flags)
+    call get_value(table, "cxx-flags", self%cxx_compile_flags)
+    call get_value(table, "link-flags", self%link_flags)
+    call get_value(table, "build-prefix", self%build_prefix)
+
+    if (allocated(self%packages)) deallocate(self%packages)
+    sub_deps: do ii = 1, size(keys)
+
+       select case (keys(ii)%key)
+          case ("compiler")
+
+               call get_value(table, keys(ii), ptr)
+               if (.not.associated(ptr)) then
+                  call fatal_error(error,'fpm_model_t: error retrieving compiler table')
+                  return
+               end if
+
+               call self%compiler%load_from_toml(ptr, error)
+               if (allocated(error)) return
+
+          case ("archiver")
+
+               call get_value(table, keys(ii), ptr)
+               if (.not.associated(ptr)) then
+                  call fatal_error(error,'fpm_model_t: error retrieving archiver table')
+                  return
+               end if
+
+               call self%archiver%load_from_toml(ptr, error)
+               if (allocated(error)) return
+
+          case ("deps")
+
+               call get_value(table, keys(ii), ptr)
+               if (.not.associated(ptr)) then
+                  call fatal_error(error,'fpm_model_t: error retrieving dependency tree table')
+                  return
+               end if
+
+               call self%deps%load_from_toml(ptr, error)
+               if (allocated(error)) return
+
+          case ("packages")
+
+               call get_value(table, keys(ii), ptr)
+               if (.not.associated(ptr)) then
+                  call fatal_error(error,'fpm_model_t: error retrieving packages table')
+                  return
+               end if
+
+               !> Read all packages
+               call ptr%get_keys(pkg_keys)
+               allocate(self%packages(size(pkg_keys)))
+
+               do jj = 1, size(pkg_keys)
+
+                   call get_value(ptr, pkg_keys(jj), ptr_pkg)
+                   call self%packages(jj)%load_from_toml(ptr_pkg, error)
+                   if (allocated(error)) return
+
+               end do
+
+
+          case default
+                cycle sub_deps
+       end select
+
+    end do sub_deps
+
+    call get_list(table, "include-dirs", self%include_dirs, error)
+    if (allocated(error)) return
+    call get_list(table, "link-libraries", self%link_libraries, error)
+    if (allocated(error)) return
+    call get_list(table, "external-modules", self%external_modules, error)
+    if (allocated(error)) return
+    call get_value(table, "include-tests", self%include_tests, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call get_value(table, "module-naming", self%enforce_module_names, error, 'fpm_model_t')
+    if (allocated(error)) return
+    call get_value(table, "module-prefix", self%module_prefix%s)
+
+end subroutine model_load_from_toml
+
 end module fpm_model
diff --git a/src/fpm_settings.f90 b/src/fpm_settings.f90
index fe4b0748fa..353728bcdf 100644
--- a/src/fpm_settings.f90
+++ b/src/fpm_settings.f90
@@ -10,7 +10,7 @@ module fpm_settings
   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 :: official_registry_base_url = 'https://fpm-registry.vercel.app'
   character(*), parameter :: default_config_file_name = 'config.toml'
 
   type :: fpm_global_settings
@@ -113,7 +113,7 @@ subroutine get_global_settings(global_settings, error)
   subroutine use_default_registry_settings(global_settings)
     type(fpm_global_settings), intent(inout) :: global_settings
 
-    allocate (global_settings%registry_settings)
+    if (.not. allocated(global_settings%registry_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_or_empty(), &
     & 'dependencies')
diff --git a/src/fpm_source_parsing.f90 b/src/fpm_source_parsing.f90
index f303a1c2cf..59f8fd4d33 100644
--- a/src/fpm_source_parsing.f90
+++ b/src/fpm_source_parsing.f90
@@ -82,9 +82,7 @@ function parse_f_source(f_filename,error) result(f_source)
 
     f_source%file_name = f_filename
 
-    open(newunit=fh,file=f_filename,status='old')
-    file_lines = read_lines_expanded(fh)
-    close(fh)
+    file_lines = read_lines_expanded(f_filename)
 
     ! for efficiency in parsing make a lowercase left-adjusted copy of the file
     ! Need a copy because INCLUDE (and #include) file arguments are case-sensitive
@@ -427,9 +425,7 @@ function parse_c_source(c_filename,error) result(c_source)
     allocate(c_source%modules_provided(0))
     allocate(c_source%parent_modules(0))
 
-    open(newunit=fh,file=c_filename,status='old')
-    file_lines = read_lines(fh)
-    close(fh)
+    file_lines = read_lines(c_filename)
 
     ! Ignore empty files, returned as FPM_UNIT_UNKNOWN
     if (len_trim(file_lines) < 1) then
diff --git a/src/fpm_sources.f90 b/src/fpm_sources.f90
index 0165249f50..4c779d5bfa 100644
--- a/src/fpm_sources.f90
+++ b/src/fpm_sources.f90
@@ -25,12 +25,16 @@ module fpm_sources
 
 !> Wrapper to source parsing routines.
 !> Selects parsing routine based on source file name extension
-function parse_source(source_file_path,error) result(source)
+function parse_source(source_file_path,custom_f_ext,error) result(source)
     character(*), intent(in) :: source_file_path
+    type(string_t), optional, intent(in) :: custom_f_ext(:)
     type(error_t), allocatable, intent(out) :: error
     type(srcfile_t)  :: source
+    type(string_t), allocatable :: f_ext(:)
 
-    if (str_ends_with(lower(source_file_path), fortran_suffixes)) then
+    call list_fortran_suffixes(f_ext,custom_f_ext)
+
+    if (str_ends_with(lower(source_file_path), f_ext)) then
 
         source = parse_f_source(source_file_path, error)
 
@@ -42,7 +46,7 @@ function parse_source(source_file_path,error) result(source)
 
         source = parse_c_source(source_file_path,error)
 
-    end if
+    endif
 
     if (allocated(error)) then
         return
@@ -50,8 +54,31 @@ function parse_source(source_file_path,error) result(source)
 
 end function parse_source
 
+!> List fortran suffixes, including optional ones
+subroutine list_fortran_suffixes(suffixes,with_f_ext)
+    type(string_t), allocatable, intent(out) :: suffixes(:)
+    !> Additional user-defined (preprocessor) extensions that should be treated as Fortran sources
+    type(string_t), intent(in), optional :: with_f_ext(:)
+
+    integer :: ndefault,nuser,i
+
+    ndefault = size(fortran_suffixes)
+    nuser    = 0; if (present(with_f_ext)) nuser = size(with_f_ext)
+
+    allocate(suffixes(ndefault + nuser))
+    do i=1,ndefault
+        suffixes(i) = string_t(fortran_suffixes(i))
+    end do
+    if (present(with_f_ext)) then
+        do i=1,nuser
+            suffixes(ndefault+i) = string_t(with_f_ext(i)%s)
+        end do
+    endif
+
+end subroutine list_fortran_suffixes
+
 !> Add to `sources` by looking for source files in `directory`
-subroutine add_sources_from_dir(sources,directory,scope,with_executables,recurse,error)
+subroutine add_sources_from_dir(sources,directory,scope,with_executables,with_f_ext,recurse,error)
     !> List of `[[srcfile_t]]` objects to append to. Allocated if not allocated
     type(srcfile_t), allocatable, intent(inout), target :: sources(:)
     !> Directory in which to search for source files
@@ -60,6 +87,8 @@ subroutine add_sources_from_dir(sources,directory,scope,with_executables,recurse
     integer, intent(in) :: scope
     !> Executable sources (fortran `program`s) are ignored unless `with_executables=.true.`
     logical, intent(in), optional :: with_executables
+    !> Additional user-defined (preprocessor) extensions that should be treated as Fortran sources
+    type(string_t), intent(in), optional :: with_f_ext(:)
     !> Whether to recursively search subdirectories, default is `.true.`
     logical, intent(in), optional :: recurse
     !> Error handling
@@ -69,7 +98,7 @@ subroutine add_sources_from_dir(sources,directory,scope,with_executables,recurse
     logical, allocatable :: is_source(:), exclude_source(:)
     logical :: recurse_
     type(string_t), allocatable :: file_names(:)
-    type(string_t), allocatable :: src_file_names(:)
+    type(string_t), allocatable :: src_file_names(:),f_ext(:)
     type(string_t), allocatable :: existing_src_files(:)
     type(srcfile_t), allocatable :: dir_sources(:)
 
@@ -87,10 +116,15 @@ subroutine add_sources_from_dir(sources,directory,scope,with_executables,recurse
         allocate(existing_src_files(0))
     end if
 
+    ! Get legal fortran suffixes
+    call list_fortran_suffixes(f_ext,with_f_ext)
+
     is_source = [(.not.(is_hidden_file(basename(file_names(i)%s))) .and. &
                  .not.(canon_path(file_names(i)%s) .in. existing_src_files) .and. &
-                 (str_ends_with(lower(file_names(i)%s), fortran_suffixes) .or. &
+                 (str_ends_with(lower(file_names(i)%s), f_ext) .or. &
                  str_ends_with(lower(file_names(i)%s), c_suffixes) ),i=1,size(file_names))]
+
+
     src_file_names = pack(file_names,is_source)
 
     allocate(dir_sources(size(src_file_names)))
@@ -98,7 +132,7 @@ subroutine add_sources_from_dir(sources,directory,scope,with_executables,recurse
 
     do i = 1, size(src_file_names)
 
-        dir_sources(i) = parse_source(src_file_names(i)%s,error)
+        dir_sources(i) = parse_source(src_file_names(i)%s,with_f_ext,error)
         if (allocated(error)) return
 
         dir_sources(i)%unit_scope = scope
@@ -129,7 +163,7 @@ end subroutine add_sources_from_dir
 !> Add to `sources` using the executable and test entries in the manifest and
 !> applies any executable-specific overrides such as `executable%name`.
 !> Adds all sources (including modules) from each `executable%source_dir`
-subroutine add_executable_sources(sources,executables,scope,auto_discover,error)
+subroutine add_executable_sources(sources,executables,scope,auto_discover,with_f_ext,error)
     !> List of `[[srcfile_t]]` objects to append to. Allocated if not allocated
     type(srcfile_t), allocatable, intent(inout), target :: sources(:)
     !> List of `[[executable_config_t]]` entries from manifest
@@ -138,6 +172,8 @@ subroutine add_executable_sources(sources,executables,scope,auto_discover,error)
     integer, intent(in) :: scope
     !> If `.false.` only executables and tests specified in the manifest are added to `sources`
     logical, intent(in) :: auto_discover
+    !> Additional user-defined (preprocessor) extensions that should be treated as Fortran sources
+    type(string_t), intent(in), optional :: with_f_ext(:)
     !> Error handling
     type(error_t), allocatable, intent(out) :: error
 
@@ -150,7 +186,7 @@ subroutine add_executable_sources(sources,executables,scope,auto_discover,error)
 
     do i=1,size(exe_dirs)
         call add_sources_from_dir(sources,exe_dirs(i)%s, scope, &
-                     with_executables=auto_discover, recurse=.false., error=error)
+                     with_executables=auto_discover, with_f_ext=with_f_ext,recurse=.false., error=error)
 
         if (allocated(error)) then
             return
@@ -163,7 +199,8 @@ subroutine add_executable_sources(sources,executables,scope,auto_discover,error)
         !  and apply any overrides
         do j=1,size(sources)
 
-            if (basename(sources(j)%file_name,suffix=.true.) == executables(i)%main .and.&
+            !> Compare lowercase strings to allow auto-discovery of pre-processed extensions
+            if (lower(basename(sources(j)%file_name,suffix=.true.)) == lower(executables(i)%main) .and.&
                  canon_path(dirname(sources(j)%file_name)) == &
                  canon_path(executables(i)%source_dir) ) then
 
@@ -180,7 +217,7 @@ subroutine add_executable_sources(sources,executables,scope,auto_discover,error)
 
         ! Add if not already discovered (auto_discovery off)
         associate(exe => executables(i))
-            exe_source = parse_source(join_path(exe%source_dir,exe%main),error)
+            exe_source = parse_source(join_path(exe%source_dir,exe%main),with_f_ext,error)
             exe_source%exe_name = exe%name
             if (allocated(exe%link)) then
                 exe_source%link_libraries = exe%link
diff --git a/src/fpm_strings.f90 b/src/fpm_strings.f90
index 6779437845..bf43a4b53b 100644
--- a/src/fpm_strings.f90
+++ b/src/fpm_strings.f90
@@ -13,6 +13,8 @@
 !! - [[LOWER]]  Changes a string to lowercase over optional specified column range
 !!### Parsing and joining
 !! - [[SPLIT]]  parse string on delimiter characters and store tokens into an allocatable array
+!! - [[SPLIT_FIRST_LAST]]  Computes the first and last indices of tokens in input string, delimited by the characters in set,
+!!                         and stores them into first and last output arrays.
 !! - [[STRING_CAT]]  Concatenate an array of **type(string_t)** into a single **CHARACTER** variable
 !! - [[JOIN]]  append an array of **CHARACTER** variables into a single **CHARACTER** variable
 !!### Testing
@@ -40,11 +42,12 @@ module fpm_strings
 implicit none
 
 private
-public :: f_string, lower, split, str_ends_with, string_t, str_begins_with_str
+public :: f_string, lower, upper, split, split_first_last, str_ends_with, string_t, str_begins_with_str
 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, dilate, remove_newline_characters
+public :: notabs, dilate, remove_newline_characters, remove_characters_in_set
+public :: operator(==)
 
 !> Module naming
 public :: is_valid_module_name, is_valid_module_prefix, &
@@ -76,6 +79,7 @@ module fpm_strings
 interface str_ends_with
     procedure :: str_ends_with_str
     procedure :: str_ends_with_any
+    procedure :: str_ends_with_any_string
 end interface str_ends_with
 
 interface str
@@ -90,6 +94,11 @@ module fpm_strings
     module procedure f_string, f_string_cptr, f_string_cptr_n
 end interface f_string
 
+interface operator(==)
+    module procedure string_is_same
+    module procedure string_arrays_same
+end interface
+
 contains
 
 !> test if a CHARACTER string ends with a specified suffix
@@ -122,6 +131,23 @@ pure logical function str_ends_with_any(s, e) result(r)
 
 end function str_ends_with_any
 
+!> Test if a CHARACTER string ends with any of an array of string suffixs
+pure logical function str_ends_with_any_string(s, e) result(r)
+    character(*), intent(in) :: s
+    type(string_t), intent(in) :: e(:)
+
+    integer :: i
+
+    r = .true.
+    do i=1,size(e)
+
+        if (str_ends_with(s,trim(e(i)%s))) return
+
+    end do
+    r = .false.
+
+end function str_ends_with_any_string
+
 !> test if a CHARACTER string begins with a specified prefix
 pure logical function str_begins_with_str(s, e, case_sensitive) result(r)
     character(*), intent(in) :: s, e
@@ -269,6 +295,37 @@ elemental pure function lower(str,begin,end) result (string)
 
 end function lower
 
+  !!License: Public Domain
+ !! Changes a string to upprtcase over optional specified column range
+elemental pure function upper(str,begin,end) result (string)
+
+    character(*), intent(In)     :: str
+    character(len(str))          :: string
+    integer,intent(in),optional  :: begin, end
+    integer                      :: i
+    integer                      :: ibegin, iend
+    string = str
+
+    ibegin = 1
+    if (present(begin))then
+        ibegin = max(ibegin,begin)
+    endif
+
+    iend = len_trim(str)
+    if (present(end))then
+        iend= min(iend,end)
+    endif
+
+    do i = ibegin, iend                               ! step thru each letter in the string in specified range
+        select case (str(i:i))
+        case ('a':'z')
+            string(i:i) = char(iachar(str(i:i))-32)   ! change letter to capitalized
+        case default
+        end select
+    end do
+
+end function upper
+
 !> Helper function to generate a new string_t instance
 !>  (Required due to the allocatable component)
 function new_string_t(s) result(string)
@@ -463,6 +520,73 @@ subroutine split(input_line,array,delimiters,order,nulls)
     enddo
 end subroutine split
 
+!! Author: Milan Curcic
+!! Computes the first and last indices of tokens in input string, delimited
+!! by the characters in set, and stores them into first and last output
+!! arrays.
+pure subroutine split_first_last(string, set, first, last)
+    character(*), intent(in) :: string
+    character(*), intent(in) :: set
+    integer, allocatable, intent(out) :: first(:)
+    integer, allocatable, intent(out) :: last(:)
+
+    integer, dimension(len(string) + 1) :: istart, iend
+    integer :: p, n, slen
+
+    slen = len(string)
+
+    n = 0
+    if (slen > 0) then
+        p = 0
+        do while (p < slen)
+            n = n + 1
+            istart(n) = min(p + 1, slen)
+            call split_pos(string, set, p)
+            iend(n) = p - 1
+        end do
+    end if
+
+    first = istart(:n)
+    last = iend(:n)
+
+end subroutine split_first_last
+
+!! Author: Milan Curcic
+!! If back is absent, computes the leftmost token delimiter in string whose
+!! position is > pos. If back is present and true, computes the rightmost
+!! token delimiter in string whose position is < pos. The result is stored
+!! in pos.
+pure subroutine split_pos(string, set, pos, back)
+    character(*), intent(in) :: string
+    character(*), intent(in) :: set
+    integer, intent(in out) :: pos
+    logical, intent(in), optional :: back
+
+    logical :: backward
+    integer :: result_pos, bound
+
+    if (len(string) == 0) then
+        pos = 1
+        return
+    end if
+
+    !TODO use optval when implemented in stdlib
+    !backward = optval(back, .false.)
+    backward = .false.
+    if (present(back)) backward = back
+
+    if (backward) then
+        bound = min(len(string), max(pos - 1, 0))
+        result_pos = scan(string(:bound), set, back=.true.)
+    else
+        result_pos = scan(string(min(pos + 1, len(string)):), set) + pos
+        if (result_pos < pos + 1) result_pos = len(string) + 1
+    end if
+
+    pos = result_pos
+
+end subroutine split_pos
+
 !> Returns string with characters in charset replaced with target_char.
 pure function replace(string, charset, target_char) result(res)
     character(*), intent(in) :: string
@@ -1221,44 +1345,106 @@ logical function has_valid_standard_prefix(module_name,package_name) result(vali
 
 end function has_valid_standard_prefix
 
-! Remove all new line characters from the current string, replace them with spaces
-subroutine remove_newline_characters(string)
-    type(string_t), intent(inout) :: string
+!> Check that two string _objects_ are exactly identical
+pure logical function string_is_same(this,that)
+   !> two strings to be compared
+   type(string_t), intent(in) :: this, that
 
-    integer :: feed,length
+   integer :: i
 
-    character(*), parameter :: CRLF  = new_line('a')//achar(13)
-    character(*), parameter :: SPACE = ' '
+   string_is_same = .false.
 
-    if (.not.allocated(string%s)) return
+   if (allocated(this%s).neqv.allocated(that%s)) return
+   if (allocated(this%s)) then
+      if (.not.len(this%s)==len(that%s)) return
+      if (.not.len_trim(this%s)==len_trim(that%s)) return
+      do i=1,len_trim(this%s)
+         if (.not.(this%s(i:i)==that%s(i:i))) return
+      end do
+   end if
 
+   ! All checks passed
+   string_is_same = .true.
 
-    length = len(string%s)
-    feed   = scan(string%s,CRLF)
+end function string_is_same
+
+!> Check that two allocatable string _object_ arrays are exactly identical
+pure logical function string_arrays_same(this,that)
+   !> two string arrays to be compared
+   type(string_t), allocatable, intent(in) :: this(:), that(:)
+
+   integer :: i
+
+   string_arrays_same = .false.
+
+   if (allocated(this).neqv.allocated(that)) return
+   if (allocated(this)) then
+      if (.not.(size(this)==size(that))) return
+      if (.not.(ubound(this,1)==ubound(that,1))) return
+      if (.not.(lbound(this,1)==lbound(that,1))) return
+      do i=lbound(this,1),ubound(this,1)
+         if (.not.string_is_same(this(i),that(i))) return
+      end do
+   end if
+
+   ! All checks passed
+   string_arrays_same = .true.
+
+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 = string_t("")
+            string = ""
 
         elseif (feed==1) then
-            string%s = string%s(2:length)
+            string = string(2:length)
 
         ! Remove trailing
         elseif (feed==length) then
-            string%s = string%s(1:length-1)
+            string = string(1:length-1)
 
-        ! In between: replace with space
+        ! In between: replace with given character
+        elseif (present(replace_with)) then
+            string(feed:feed) = replace_with
+        ! Or just remove
         else
-            string%s(feed:feed) = SPACE
+            string = string(1:feed-1)//string(feed+1:length)
         end if
 
-        length = len(string%s)
-        feed   = scan(string%s,CRLF)
+        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  = achar(13)//new_line('a')
+    character(*), parameter :: SPACE = ' '
+
+    call remove_characters_in_set(string%s,set=CRLF,replace_with=SPACE)
+
 end subroutine remove_newline_characters
 
 !>AUTHOR: John S. Urban
diff --git a/src/fpm_targets.f90 b/src/fpm_targets.f90
index bc31f1594b..bcf5235ab0 100644
--- a/src/fpm_targets.f90
+++ b/src/fpm_targets.f90
@@ -33,13 +33,15 @@ module fpm_targets
 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
+use fpm_manifest_preprocess, only: preprocess_config_t
 implicit none
 
 private
 
 public FPM_TARGET_UNKNOWN, FPM_TARGET_EXECUTABLE, &
        FPM_TARGET_ARCHIVE, FPM_TARGET_OBJECT, &
-       FPM_TARGET_C_OBJECT, FPM_TARGET_CPP_OBJECT
+       FPM_TARGET_C_OBJECT, FPM_TARGET_CPP_OBJECT, &
+       FPM_TARGET_NAME
 public build_target_t, build_target_ptr
 public targets_from_sources, resolve_module_dependencies
 public add_target, add_dependency
@@ -136,6 +138,22 @@ module fpm_targets
 
 contains
 
+!> Target type name
+pure function FPM_TARGET_NAME(type) result(msg)
+   integer, intent(in) :: type
+   character(:), allocatable :: msg
+
+   select case (type)
+      case (FPM_TARGET_ARCHIVE);    msg = 'Archive'
+      case (FPM_TARGET_CPP_OBJECT); msg = 'C++ object'
+      case (FPM_TARGET_C_OBJECT);   msg = 'C Object'
+      case (FPM_TARGET_EXECUTABLE); msg = 'Executable'
+      case (FPM_TARGET_OBJECT);     msg = 'Object'
+      case default;                 msg = 'Unknown'
+   end select
+
+end function FPM_TARGET_NAME
+
 !> High-level wrapper to generate build target information
 subroutine targets_from_sources(targets,model,prune,error)
 
@@ -198,15 +216,14 @@ subroutine build_target_list(targets,model)
     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 (n_source < 1) return
 
     with_lib = any([((model%packages(j)%sources(i)%unit_scope == FPM_SCOPE_LIB, &
                       i=1,size(model%packages(j)%sources)), &
@@ -234,7 +251,7 @@ subroutine build_target_list(targets,model)
                                                sources(i)%unit_type==FPM_UNIT_CSOURCE), &
                                 output_name = get_object_name(sources(i)), &
                                 features = model%packages(j)%features, &
-                                macros = model%packages(j)%macros, &
+                                preprocess = model%packages(j)%preprocess, &
                                 version = model%packages(j)%version)
 
 
@@ -248,7 +265,7 @@ subroutine build_target_list(targets,model)
                     call add_target(targets,package=model%packages(j)%name,source = sources(i), &
                                 type = FPM_TARGET_CPP_OBJECT, &
                                 output_name = get_object_name(sources(i)), &
-                                macros = model%packages(j)%macros, &
+                                preprocess = model%packages(j)%preprocess, &
                                 version = model%packages(j)%version)
 
                     if (with_lib .and. sources(i)%unit_scope == FPM_SCOPE_LIB) then
@@ -281,7 +298,7 @@ subroutine build_target_list(targets,model)
                                 output_name = get_object_name(sources(i)), &
                                 source = sources(i), &
                                 features = model%packages(j)%features, &
-                                macros = model%packages(j)%macros &
+                                preprocess = model%packages(j)%preprocess &
                                 )
 
                     if (sources(i)%unit_scope == FPM_SCOPE_APP) then
@@ -414,7 +431,7 @@ end subroutine collect_exe_link_dependencies
 
 !> Allocate a new target and append to target list
 subroutine add_target(targets, package, type, output_name, source, link_libraries, &
-        & features, macros, version)
+        & features, preprocess, version)
     type(build_target_ptr), allocatable, intent(inout) :: targets(:)
     character(*), intent(in) :: package
     integer, intent(in) :: type
@@ -422,7 +439,7 @@ subroutine add_target(targets, package, type, output_name, source, link_librarie
     type(srcfile_t), intent(in), optional :: source
     type(string_t), intent(in), optional :: link_libraries(:)
     type(fortran_features_t), intent(in), optional :: features
-    type(string_t), intent(in), optional :: macros(:)
+    type(preprocess_config_t), intent(in), optional :: preprocess
     character(*), intent(in), optional :: version
 
     integer :: i
@@ -451,7 +468,9 @@ subroutine add_target(targets, package, type, output_name, source, link_librarie
     if (present(source)) new_target%source = source
     if (present(link_libraries)) new_target%link_libraries = link_libraries
     if (present(features)) new_target%features = features
-    if (present(macros)) new_target%macros = macros
+    if (present(preprocess)) then
+        if (allocated(preprocess%macros)) new_target%macros = preprocess%macros
+    endif
     if (present(version)) new_target%version = version
     allocate(new_target%dependencies(0))
 
@@ -826,7 +845,7 @@ subroutine resolve_target_linking(targets, model)
             if (.not.allocated(target%compile_flags)) allocate(character(len=0) :: target%compile_flags)
 
             target%compile_flags = target%compile_flags//' '
-            
+
             select case (target%target_type)
                case (FPM_TARGET_C_OBJECT)
                    target%compile_flags = target%compile_flags//model%c_compile_flags
@@ -835,7 +854,7 @@ subroutine resolve_target_linking(targets, model)
                case default
                    target%compile_flags = target%compile_flags//model%fortran_compile_flags &
                                         & // get_feature_flags(model%compiler, target%features)
-            end select   
+            end select
 
             !> Get macros as flags.
             target%compile_flags = target%compile_flags // get_macros(model%compiler%id, &
diff --git a/test/cli_test/cli_test.f90 b/test/cli_test/cli_test.f90
index f5336b62ca..975b80812b 100644
--- a/test/cli_test/cli_test.f90
+++ b/test/cli_test/cli_test.f90
@@ -29,6 +29,7 @@ program main
 logical                              :: w_t,act_w_t          ; namelist/act_cli/act_w_t
 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                              :: reg_c,act_reg_c      ; namelist/act_cli/act_reg_c
 logical                              :: show_v,act_show_v    ; namelist/act_cli/act_show_v
 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
@@ -36,7 +37,7 @@ program main
 
 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_u_d,dry_run,token
+namelist/expected/cmd,cstat,estat,w_e,w_t,c_s,c_a,reg_c,name,profile,args,show_v,show_u_d,dry_run,token
 integer                              :: lun
 logical,allocatable                  :: tally(:)
 logical,allocatable                  :: subtally(:)
@@ -75,6 +76,7 @@ program main
 'CMD="clean",                                                      NAME=, ARGS="",', &
 'CMD="clean --skip",                                        C_S=T, NAME=, ARGS="",', &
 'CMD="clean --all",                                         C_A=T, NAME=, ARGS="",', &
+'CMD="clean --registry-cache",                            REG_C=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="",', &
@@ -111,6 +113,7 @@ program main
       w_t=.false.                    ! --test
       c_s=.false.                    ! --skip
       c_a=.false.                    ! --all
+      reg_c=.false.                  ! --registry-cache
       show_v=.false.                 ! --show-package-version
       show_u_d=.false.               ! --show-upload-data
       dry_run=.false.                ! --dry-run
@@ -134,6 +137,7 @@ program main
              act_w_t=.false.
              act_c_s=.false.
              act_c_a=.false.
+             act_reg_c=.false.
              act_show_v=.false.
              act_show_u_d=.false.
              act_dry_run=.false.
@@ -148,6 +152,9 @@ program main
              subtally=[logical ::]
              call test_test('NAME',all(act_name==name))
              call test_test('PROFILE',act_profile==profile)
+             call test_test('SKIP',act_c_s.eqv.c_s)
+             call test_test('ALL',act_c_a.eqv.c_a)
+             call test_test('REGISTRY-CACHE',act_reg_c.eqv.reg_c)
              call test_test('WITH_EXPECTED',act_w_e.eqv.w_e)
              call test_test('WITH_TESTED',act_w_t.eqv.w_t)
              call test_test('WITH_TEST',act_w_t.eqv.w_t)
@@ -241,6 +248,7 @@ subroutine parse()
 act_w_t=.false.
 act_c_s=.false.
 act_c_a=.false.
+act_reg_c=.false.
 act_show_v=.false.
 act_show_u_d=.false.
 act_dry_run=.false.
@@ -264,7 +272,8 @@ subroutine parse()
     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
+    act_c_a=settings%clean_all
+    act_reg_c=settings%registry_cache
 type is (fpm_install_settings)
 type is (fpm_publish_settings)
     act_show_v=settings%show_package_version
@@ -275,7 +284,6 @@ subroutine parse()
 
 open(file='_test_cli',newunit=lun,delim='quote')
 write(lun,nml=act_cli,delim='quote')
-!!write(*,nml=act_cli)
 close(unit=lun)
 
 end subroutine parse
diff --git a/test/fpm_test/test_manifest.f90 b/test/fpm_test/test_manifest.f90
index be86b311cb..ddabe3cf49 100644
--- a/test/fpm_test/test_manifest.f90
+++ b/test/fpm_test/test_manifest.f90
@@ -167,6 +167,10 @@ subroutine test_valid_manifest(error)
             return
         end if
 
+        ! Test package serialization
+        call package%test_serialization('test_valid_manifest',error)
+        if (allocated(error)) return
+
     end subroutine test_valid_manifest
 
 
@@ -220,6 +224,9 @@ subroutine test_default_library(error)
             return
         end if
 
+        call package%test_serialization('test_default_library',error)
+        if (allocated(error)) return
+
     end subroutine test_default_library
 
 
@@ -243,6 +250,9 @@ subroutine test_default_executable(error)
             & "Default executable name")
         if (allocated(error)) return
 
+        call package%test_serialization('test_default_executable',error)
+        if (allocated(error)) return
+
     end subroutine test_default_executable
 
 
@@ -517,6 +527,9 @@ subroutine test_profiles(error)
             return
         end if
 
+        call chosen_profile%test_serialization('profile serialization: '//profile_name//' '//compiler,error)
+        if (allocated(error)) return
+
         profile_name = 'release'
         compiler = 'gfortran'
         call find_profile(package%profiles, profile_name, compiler, 3, profile_found, chosen_profile)
@@ -525,6 +538,9 @@ subroutine test_profiles(error)
             return
         end if
 
+        call chosen_profile%test_serialization('profile serialization: '//profile_name//' '//compiler,error)
+        if (allocated(error)) return
+
         profile_name = 'publish'
         compiler = 'gfortran'
         call find_profile(package%profiles, profile_name, compiler, 1, profile_found, chosen_profile)
@@ -533,6 +549,9 @@ subroutine test_profiles(error)
             return
         end if
 
+        call chosen_profile%test_serialization('profile serialization: '//profile_name//' '//compiler,error)
+        if (allocated(error)) return
+
         profile_name = 'debug'
         compiler = 'ifort'
         call find_profile(package%profiles, profile_name, compiler, 3, profile_found, chosen_profile)
@@ -542,6 +561,9 @@ subroutine test_profiles(error)
             return
         end if
 
+        call chosen_profile%test_serialization('profile serialization: '//profile_name//' '//compiler,error)
+        if (allocated(error)) return
+
         profile_name = 'release'
         compiler = 'ifort'
         call find_profile(package%profiles, profile_name, compiler, 1, profile_found, chosen_profile)
@@ -549,6 +571,10 @@ subroutine test_profiles(error)
             call test_failed(error, "Failed to overwrite built-in profile")
             return
         end if
+
+        call chosen_profile%test_serialization('profile serialization: '//profile_name//' '//compiler,error)
+        if (allocated(error)) return
+
     end subroutine test_profiles
 
     !> 'flags' is a key-value entry, test should fail as it is defined as a table
@@ -1207,6 +1233,11 @@ subroutine test_link_string(error)
         call set_value(table, "link", "z", stat=stat)
 
         call new_build_config(build, table, 'test_link_string', error)
+        if (allocated(error)) return
+
+        !> Test serialization roundtrip
+        call build%test_serialization('test_link_string', error)
+        if (allocated(error)) return
 
     end subroutine test_link_string
 
@@ -1230,6 +1261,11 @@ subroutine test_link_array(error)
         call set_value(children, 2, "lapack", stat=stat)
 
         call new_build_config(build, table, 'test_link_array', error)
+        if (allocated(error)) return
+
+        !> Test serialization roundtrip
+        call build%test_serialization('test_link_array', error)
+        if (allocated(error)) return
 
     end subroutine test_link_array
 
diff --git a/test/fpm_test/test_package_dependencies.f90 b/test/fpm_test/test_package_dependencies.f90
index 4f645750b5..f87f3f02f4 100644
--- a/test/fpm_test/test_package_dependencies.f90
+++ b/test/fpm_test/test_package_dependencies.f90
@@ -108,13 +108,13 @@ subroutine test_cache_dump_load(error)
     call new_dependency_node(deps%dep(3), dep, proj_dir=dep%path)
 
     open (newunit=unit, status='scratch')
-    call deps%dump(unit, error)
+    call deps%dump_cache(unit, error)
     if (.not. allocated(error)) then
       rewind (unit)
 
       call new_dependency_tree(deps)
       call resize(deps%dep, 2)
-      call deps%load(unit, error)
+      call deps%load_cache(unit, error)
       close (unit)
     end if
     if (allocated(error)) return
@@ -155,7 +155,7 @@ subroutine test_cache_load_dump(error)
     call set_value(ptr, "proj-dir", "fpm-tmp4-dir")
 
     call new_dependency_tree(deps)
-    call deps%load(table, error)
+    call deps%load_cache(table, error)
     if (allocated(error)) return
 
     if (deps%ndep /= 4) then
@@ -166,7 +166,7 @@ subroutine test_cache_load_dump(error)
     call table%destroy
     table = toml_table()
 
-    call deps%dump(table, error)
+    call deps%dump_cache(table, error)
     if (allocated(error)) return
 
     call table%get_keys(list)
@@ -197,7 +197,7 @@ subroutine test_status(error)
     call set_value(ptr, "git", "https://github.com/fortran-lang/dep2")
 
     call new_dependency_tree(deps)
-    call deps%load(table, error)
+    call deps%load_cache(table, error)
     if (allocated(error)) return
 
     if (deps%finished()) then
@@ -289,7 +289,7 @@ subroutine test_non_updated_dependencies(error)
 
     ! Load into a dependency tree
     call new_dependency_tree(cached)
-    call cached%load(cache, error)
+    call cached%load_cache(cache, error)
     if (allocated(error)) return
     ! Mark all dependencies as "cached"
     do ii=1,cached%ndep
@@ -313,7 +313,7 @@ subroutine test_non_updated_dependencies(error)
 
     ! Load dependencies from manifest
     call new_dependency_tree(manifest_deps)
-    call manifest_deps%load(manifest, error)
+    call manifest_deps%load_cache(manifest, error)
     call manifest%destroy()
     if (allocated(error)) return
 
@@ -334,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")
@@ -373,7 +372,7 @@ subroutine test_update_dependencies(error)
 
     ! Load into a dependency tree
     call new_dependency_tree(cached)
-    call cached%load(cache, error)
+    call cached%load_cache(cache, error)
     if (allocated(error)) return
     ! Mark all dependencies as "cached"
     do ii=1,cached%ndep
@@ -397,7 +396,7 @@ subroutine test_update_dependencies(error)
 
     ! Load dependencies from manifest
     call new_dependency_tree(manifest_deps)
-    call manifest_deps%load(manifest, error)
+    call manifest_deps%load_cache(manifest, error)
     call manifest%destroy()
     if (allocated(error)) return
 
diff --git a/test/fpm_test/test_source_parsing.f90 b/test/fpm_test/test_source_parsing.f90
index 9a5f5802ec..c407d0c857 100644
--- a/test/fpm_test/test_source_parsing.f90
+++ b/test/fpm_test/test_source_parsing.f90
@@ -119,6 +119,8 @@ subroutine test_modules_used(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_modules_used
 
 
@@ -186,6 +188,8 @@ subroutine test_intrinsic_modules_used(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_intrinsic_modules_used
 
 
@@ -315,6 +319,8 @@ subroutine test_include_stmt(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_include_stmt
 
     !> Try to parse a simple fortran program
@@ -370,6 +376,8 @@ subroutine test_program(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_program
 
 
@@ -452,6 +460,8 @@ subroutine test_module(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_module
 
 
@@ -501,6 +511,8 @@ subroutine test_module_with_subprogram(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_module_with_subprogram
 
 
@@ -566,6 +578,8 @@ subroutine test_module_end_stmt(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_module_end_stmt
 
 
@@ -614,6 +628,8 @@ subroutine test_module_with_c_api(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_module_with_c_api
 
 
@@ -677,6 +693,8 @@ subroutine test_program_with_module(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_program_with_module
 
 
@@ -734,6 +752,8 @@ subroutine test_submodule(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_submodule
 
 
@@ -791,6 +811,8 @@ subroutine test_submodule_ancestor(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_submodule_ancestor
 
 
@@ -839,6 +861,8 @@ subroutine test_subprogram(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_subprogram
 
 
@@ -909,6 +933,8 @@ subroutine test_csource(error)
             return
         end if
 
+        call f_source%test_serialization('srcfile_t: serialization', error)
+
     end subroutine test_csource
 
     !> Try to parse fortran program with invalid use statement
diff --git a/test/fpm_test/test_toml.f90 b/test/fpm_test/test_toml.f90
index 1ffea1d651..ad0a8b40c9 100644
--- a/test/fpm_test/test_toml.f90
+++ b/test/fpm_test/test_toml.f90
@@ -2,11 +2,30 @@
 module test_toml
     use testsuite, only : new_unittest, unittest_t, error_t
     use fpm_toml
+    use tomlf_constants, only: tf_i8
+    use fpm_git
+    use fpm_dependency, only: dependency_node_t, destroy_dependency_node, dependency_tree_t, &
+         & new_dependency_node, new_dependency_tree, resize
+    use fpm_manifest_dependency, only: dependency_config_t, dependency_destroy
+    use fpm_manifest_install
+    use fpm_manifest_fortran
+    use fpm_manifest_library
+    use fpm_manifest_executable
+    use fpm_manifest_preprocess
+    use fpm_manifest_profile
+    use fpm_versioning, only: new_version
+    use fpm_strings, only: string_t, operator(==), split
+    use fpm_model, only: fortran_features_t, package_t, FPM_SCOPE_LIB, FPM_UNIT_MODULE, fpm_model_t, &
+         & srcfile_t
+    use fpm_compiler, only: archiver_t, compiler_t, id_gcc
+
+
     implicit none
     private
 
     public :: collect_toml
 
+    character, parameter :: NL = new_line('a')
 
 contains
 
@@ -18,9 +37,36 @@ subroutine collect_toml(testsuite)
         type(unittest_t), allocatable, intent(out) :: testsuite(:)
 
         testsuite = [ &
-            & new_unittest("valid-toml", test_valid_toml), &
-            & new_unittest("invalid-toml", test_invalid_toml, should_fail=.true.), &
-            & new_unittest("missing-file", test_missing_file, should_fail=.true.)]
+           & new_unittest("valid-toml", test_valid_toml), &
+           & new_unittest("invalid-toml", test_invalid_toml, should_fail=.true.), &
+           & new_unittest("missing-file", test_missing_file, should_fail=.true.), &
+           & new_unittest("serialize-git-target", git_target_roundtrip), &
+           & new_unittest("serialize-git-invalid", git_target_invalid, should_fail=.true.), &
+           & new_unittest("serialize-dependency-config", dependency_config_roundtrip), &
+           & new_unittest("serialize-dependency-node", dependency_node_roundtrip), &
+           & new_unittest("serialize-dependency-invalid", dependency_node_invalid, should_fail=.true.), &
+           & new_unittest("serialize-dependency-invalid2", dependency_node_invalid_2, should_fail=.true.), &
+           & new_unittest("serialize-dependency-tree", dependency_tree_roundtrip), &
+           & new_unittest("serialize-dependency-tree-invalid", dependency_tree_invalid, should_fail=.true.), &
+           & new_unittest("serialize-dependency-tree-invalid2", dependency_tree_invalid2, should_fail=.true.), &
+           & new_unittest("serialize-install-config", install_config_roundtrip), &
+           & new_unittest("serialize-fortran-config", fortran_features_roundtrip), &
+           & new_unittest("serialize-library-config", library_config_roundtrip), &
+           & new_unittest("serialize-executable-config", executable_config_roundtrip), &
+           & new_unittest("serialize-preprocess-config", preprocess_config_roundtrip), &
+           & new_unittest("serialize-file-scope-flag", file_scope_flag_roundtrip), &
+           & new_unittest("serialize-string-array", string_array_roundtrip), &
+           & new_unittest("serialize-fortran-features", fft_roundtrip), &
+           & new_unittest("serialize-fortran-invalid", fft_invalid, should_fail=.true.), &
+           & new_unittest("serialize-package", package_roundtrip), &
+           & new_unittest("serialize-package-invalid", package_invalid, should_fail=.true.), &
+           & new_unittest("serialize-srcfile-invalid", source_invalid, should_fail=.true.), &
+           & new_unittest("serialize-archiver", ar_roundtrip), &
+           & new_unittest("serialize-archiver-invalid", ar_invalid, should_fail=.true.), &
+           & new_unittest("serialize-compiler", compiler_roundtrip), &
+           & new_unittest("serialize-compiler-invalid", compiler_invalid, should_fail=.true.), &
+           & new_unittest("serialize-model", fpm_model_roundtrip), &
+           & new_unittest("serialize-model-invalid", fpm_model_invalid, should_fail=.true.)]
 
     end subroutine collect_toml
 
@@ -103,5 +149,1145 @@ subroutine test_missing_file(error)
 
     end subroutine test_missing_file
 
+    !> Test git_target_t serialization
+    subroutine git_target_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(git_target_t) :: git
+
+        ! Revision type
+        git = git_target_revision(url="https://github.com/urbanjost/M_CLI2.git", &
+                                  sha1="7264878cdb1baff7323cc48596d829ccfe7751b8")
+        call git%test_serialization("revision git type",error)
+        if (allocated(error)) return
+
+        ! Branch type
+        git = git_target_branch(url="https://github.com/urbanjost/M_CLI2.git", &
+                                branch="main")
+        call git%test_serialization("branch git type",error)
+        if (allocated(error)) return
+
+        ! Tag type
+        git = git_target_tag(url="https://github.com/urbanjost/M_CLI2.git", &
+                             tag="1.0.0")
+        call git%test_serialization("target git type",error)
+        if (allocated(error)) return
+
+        ! Incomplete type
+        if (allocated(git%object)) deallocate(git%object)
+        call git%test_serialization("incomplete git type 1/2",error)
+        if (allocated(error)) return
+
+        ! Incomplete type
+        if (allocated(git%url)) deallocate(git%url)
+        call git%test_serialization("incomplete git type 2/2",error)
+        if (allocated(error)) return
+
+    end subroutine git_target_roundtrip
+
+
+    !> Test invalid git_target_t serialization
+    subroutine git_target_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(git_target_t) :: git
+        type(toml_table), allocatable :: table
+
+        character(*), parameter :: toml = 'descriptor = ""'//NL//& ! invalid descriptor ID
+                                          'url = "https://github.com/toml-f/toml-f"'//NL//&
+                                          'object = "54686e45993f3a9a1d05d5c7419f39e7d5a4eb3f"'
+
+
+        call string_to_toml(toml, table)
+
+        call git%load(table, error)
+
+    end subroutine git_target_invalid
+
+    !> Test git_target_t serialization
+    subroutine dependency_config_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(dependency_config_t) :: dep
+
+        call dependency_destroy(dep)
+
+        dep%name = "M_CLI2"
+        dep%path = "~/./some/dummy/path"
+        dep%namespace = "urbanjost"
+        allocate(dep%requested_version)
+        call new_version(dep%requested_version, "3.2.0",error); if (allocated(error)) return
+
+        allocate(dep%git)
+        dep%git = git_target_revision(url="https://github.com/urbanjost/M_CLI2.git", &
+                                      sha1="7264878cdb1baff7323cc48596d829ccfe7751b8")
+
+        ! Test full object
+        call dep%test_serialization("full object",error)
+        if (allocated(error)) return
+
+        ! Remove namespace
+        deallocate(dep%namespace)
+        call dep%test_serialization("no namespace",error)
+        if (allocated(error)) return
+
+        ! Remove git
+        deallocate(dep%git)
+        call dep%test_serialization("no git",error)
+        if (allocated(error)) return
+
+        ! Remove version
+        deallocate(dep%requested_version)
+        call dep%test_serialization("no requested_version",error)
+        if (allocated(error)) return
+
+        ! Remove name
+        deallocate(dep%name)
+        call dep%test_serialization("no name",error)
+        if (allocated(error)) return
+
+        ! Remove path
+        deallocate(dep%path)
+        call dep%test_serialization("no path",error)
+        if (allocated(error)) return
+
+    end subroutine dependency_config_roundtrip
+
+    !> Test dependency_node_t serialization
+    subroutine dependency_node_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(dependency_node_t) :: dep
+
+        call destroy_dependency_node(dep)
+
+        dep%name = "M_CLI2"
+        dep%path = "~/./some/dummy/path"
+        dep%proj_dir = "~/./"
+        dep%namespace = "urbanjost"
+        dep%revision = "7264878cdb1baff7323cc48596d829ccfe7751b8"
+        dep%cached = .true.
+        dep%done = .false.
+        dep%update = .true.
+        allocate(dep%requested_version)
+        call new_version(dep%requested_version, "3.2.0",error); if (allocated(error)) return
+        allocate(dep%version)
+        call new_version(dep%version, "4.53.2",error); if (allocated(error)) return
+
+        allocate(dep%git)
+        dep%git = git_target_revision(url="https://github.com/urbanjost/M_CLI2.git", &
+                                      sha1="7264878cdb1baff7323cc48596d829ccfe7751b8")
+
+        ! Test full object
+        call dep%test_serialization("full object",error)
+        if (allocated(error)) return
+
+        ! Remove namespace
+        deallocate(dep%namespace)
+        call dep%test_serialization("no namespace",error)
+        if (allocated(error)) return
+
+        ! Remove git
+        deallocate(dep%git)
+        call dep%test_serialization("no git",error)
+        if (allocated(error)) return
+
+        ! Remove version
+        deallocate(dep%requested_version)
+        call dep%test_serialization("no requested_version",error)
+        if (allocated(error)) return
+
+        ! Remove name
+        deallocate(dep%name)
+        call dep%test_serialization("no name",error)
+        if (allocated(error)) return
+
+        ! Remove path
+        deallocate(dep%path)
+        call dep%test_serialization("no path",error)
+        if (allocated(error)) return
+
+        ! Remove revision
+        deallocate(dep%revision)
+        call dep%test_serialization("no revision",error)
+        if (allocated(error)) return
+
+        ! Remove proj_dir
+        deallocate(dep%proj_dir)
+        call dep%test_serialization("no proj_dir",error)
+        if (allocated(error)) return
+
+        ! Remove version
+        deallocate(dep%version)
+        call dep%test_serialization("no version",error)
+        if (allocated(error)) return
+
+    end subroutine dependency_node_roundtrip
+
+    !> Test loading invalid dependency node
+    subroutine dependency_node_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(dependency_node_t) :: dep
+        type(toml_table), allocatable :: table
+
+        character(*), parameter :: toml = 'name = "jonquil" '//NL//&
+                                        & 'version = "h0.2.0"'//NL//& ! invalid version
+                                        & 'proj-dir = "build/dependencies/jonquil"'//NL//&
+                                        & 'revision = "05d30818bb12fb877226ce284b9a3a41b971a889"'//NL//&
+                                        & 'done = true'//NL//&
+                                        & 'update = false'//NL//&
+                                        & 'cached = true'
+
+        call string_to_toml(toml, table)
+
+        call dep%load(table, error)
+
+    end subroutine dependency_node_invalid
+
+    !> Test loading invalid dependency node
+    subroutine dependency_node_invalid_2(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(dependency_node_t) :: dep
+        type(toml_table), allocatable :: table
+
+        character(*), parameter :: toml = 'name = "jonquil" '//NL//&
+                                        & 'version = "0.2.0"'//NL//&
+                                        & 'proj-dir = "build/dependencies/jonquil"'//NL//&
+                                        & 'revision = "05d30818bb12fb877226ce284b9a3a41b971a889"'//NL//&
+                                        & 'done = 123'//NL//&  ! not a boolean
+                                        & 'update = false'//NL//&
+                                        & 'cached = true'
+
+        call string_to_toml(toml, table)
+        call dep%load(table, error)
+
+    end subroutine dependency_node_invalid_2
+
+    !> Test dependency_tree_t serialization
+    subroutine dependency_tree_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(dependency_tree_t) :: deps
+        type(dependency_config_t) :: dep
+
+        integer, parameter :: ALLOCATED_DEPS = 5
+        character(36) :: msg
+        integer :: ii
+
+        ! Generate dummy tree with ndep=3 but 5 allocated dependencies
+        call new_dependency_tree(deps)
+        call resize(deps%dep, ALLOCATED_DEPS)
+        deps%ndep = 3
+        dep%name = "dep1"
+        dep%path = "fpm-tmp1-dir"
+        call new_dependency_node(deps%dep(1), dep, proj_dir=dep%path)
+        dep%name = "dep2"
+        dep%path = "fpm-tmp2-dir"
+        call new_dependency_node(deps%dep(2), dep, proj_dir=dep%path)
+        deps%dep(3)%name = "M_CLI2"
+        deps%dep(3)%path = "~/./some/dummy/path"
+        deps%dep(3)%proj_dir = "~/./"
+        deps%dep(3)%namespace = "urbanjost"
+        deps%dep(3)%revision = "7264878cdb1baff7323cc48596d829ccfe7751b8"
+        deps%dep(3)%cached = .true.
+        deps%dep(3)%done = .false.
+        deps%dep(3)%update = .true.
+        allocate(deps%dep(3)%requested_version)
+        call new_version(deps%dep(3)%requested_version, "3.2.0",error); if (allocated(error)) return
+        allocate(deps%dep(3)%version)
+        call new_version(deps%dep(3)%version, "4.53.2",error); if (allocated(error)) return
+        allocate(deps%dep(3)%git)
+        deps%dep(3)%git = git_target_revision(url="https://github.com/urbanjost/M_CLI2.git", &
+                                              sha1="7264878cdb1baff7323cc48596d829ccfe7751b8")
+
+        call deps%test_serialization("full dependency tree", error)
+        if (allocated(error)) return
+
+        ! Remove dependencies (including all them)
+        do ii = 1, ALLOCATED_DEPS
+            write(msg,1) ii
+            call resize(deps%dep, size(deps%dep) - 1)
+            call deps%test_serialization(trim(msg), error)
+            if (allocated(error)) return
+        end do
+
+        ! deallocate dependencies
+        deallocate(deps%dep)
+        call deps%test_serialization("unallocated deps(:)", error)
+        if (allocated(error)) return
+
+        ! Remove deps dir
+        deallocate(deps%dep_dir)
+        call deps%test_serialization("no deps dir", error)
+        if (allocated(error)) return
+
+        1 format('removed ',i0,' dependencies')
+
+    end subroutine dependency_tree_roundtrip
+
+    !> Test invalid dependency tree loading
+    subroutine dependency_tree_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(toml_table), allocatable :: table
+        type(dependency_tree_t) :: dep
+
+        character(len=*), parameter :: toml = &
+            & 'unit = 6 '//NL//&
+            & 'verbosity = true'//NL//& ! not a number
+            & 'dep-dir = "build/dependencies"'//NL//&
+            & 'ndep = 3'//NL//& ! consistency is not checked:
+            & '[dependencies]'//NL//&
+            & '[dependencies.dep1]'//NL//&
+            & 'name = "dep1"'//NL//&
+            & 'path = "fpm-tmp1-dir"'//NL//&
+            & 'proj-dir = "fpm-tmp1-dir"'//NL//&
+            & 'done = false'//NL//&
+            & 'update = false'//NL//&
+            & 'cached = false'
+
+        call string_to_toml(toml, table)
+        call dep%load(table, error)
+
+    end subroutine dependency_tree_invalid
+
+    !> Test invalid dependency tree loading
+    subroutine dependency_tree_invalid2(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(toml_table), allocatable :: table
+        type(dependency_tree_t) :: dep
+
+        character(len=*), parameter :: toml = &
+            & 'unit = "" '//NL//& ! not provided
+            & 'verbosity = 1'//NL//&
+            & 'dep-dir = "build/dependencies"'//NL//&
+            & 'ndep = 3'//NL//& ! consistency is not checked:
+            & '[dependencies.M_CLI2]'//NL//&
+            & 'name = "M_CLI2"'//NL//&
+            & 'path = "~/./some/dummy/path"'//NL//&
+            & 'namespace = "urbanjost"'//NL//&
+            & 'requested_version = "3.2.0"'//NL//&
+            & 'version = "4.53.2"'//NL//&
+            & 'proj-dir = "~/./"'//NL//&
+            & 'revision = "7264878cdb1baff7323cc48596d829ccfe7751b8"'//NL//&
+            & 'done = false'//NL//&
+            & 'update = true'//NL//&
+            & 'cached = true'//NL//&
+            & '[dependencies.M_CLI2.git]'//NL//&
+            & 'descriptor = "revision"'//NL//&
+            & 'url = "https://github.com/urbanjost/M_CLI2.git"'//NL//&
+            & 'object = "7264878cdb1baff7323cc48596d829ccfe7751b8"'
+
+        call string_to_toml(toml, table)
+        call dep%load(table, error)
+
+    end subroutine dependency_tree_invalid2
+
+    !> Test serialization/deserialization of a string array
+    subroutine string_array_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(len=*), parameter :: lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing " &
+            & //"elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad " &
+            & //"minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo " &
+            & //"consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum " &
+            & //"dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt " &
+            & //"in culpa qui officia deserunt mollit anim id est laborum"
+
+        integer :: ii, nword
+        character(len=:), allocatable :: tokens(:)
+        type(string_t), allocatable :: list(:),copy(:)
+        type(toml_table) :: table
+        character(len=16) :: key
+
+        call split(lorem, tokens)
+        nword = size(tokens)
+
+        !> Convert to string_t array
+        allocate(list(nword))
+        do ii = 1, nword
+            list(ii) = string_t(trim(tokens(ii)))
+        end do
+
+        ! Test list with any length
+        do ii = nword, 1, -1
+
+            ! Shorten list
+            list = list(1:ii)
+
+            ! Set list to table
+            table = toml_table()
+
+            call set_list(table, key="lorem-ipsum", list=list, error=error)
+            if (allocated(error)) return
+
+            ! Load list from table
+            call get_list(table, key="lorem-ipsum", list=copy, error=error)
+            if (allocated(error)) return
+
+            if (.not.(list==copy)) then
+               call fatal_error(error,'string_array is not equal after TOML roundtrip')
+               return
+            end if
+
+        end do
+
+        ! Test empty list
+        deallocate(list)
+        allocate(list(0))
+        ! Set list to table
+        table = toml_table()
+
+        call set_list(table, key="lorem-ipsum", list=list, error=error)
+        if (allocated(error)) return
+
+        ! Load list from table
+        call get_list(table, key="lorem-ipsum", list=copy, error=error)
+        if (allocated(error)) return
+
+        if (.not.(list==copy)) then
+           call fatal_error(error,'empty string_array is not equal after TOML roundtrip')
+           return
+        end if
+
+        ! Test unallocated list
+        deallocate(list)
+        table = toml_table()
+
+        call set_list(table, key="lorem-ipsum", list=list, error=error)
+        if (allocated(error)) return
+
+        ! Load list from table
+        call get_list(table, key="lorem-ipsum", list=copy, error=error)
+        if (allocated(error)) return
+
+        if (.not.(list==copy)) then
+           call fatal_error(error,'deallocated string_array is not equal after TOML roundtrip')
+           return
+        end if
+
+        1 format('word_',i0)
+
+    end subroutine string_array_roundtrip
+
+    !> Test serialization/deserialization of a fortran-features structure
+    subroutine fft_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(fortran_features_t) :: fortran
+
+        !> Default object
+        call fortran%test_serialization('fortran_features_t: default object',error)
+        if (allocated(error)) return
+
+        !> Set form
+        fortran%source_form = "free"
+        call fortran%test_serialization('fortran_features_t: with form',error)
+        if (allocated(error)) return
+
+    end subroutine fft_roundtrip
+
+    !> Test deserialization of an invalid fortran-features structure
+    subroutine fft_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(fortran_features_t) :: fortran
+        type(toml_table), allocatable :: table
+
+        character(len=*), parameter :: toml = 'implicit-typing = false '//NL//&
+                                            & 'implicit-external = 0 '//NL//& ! not a boolean
+                                            & 'source-form = "free" '
+
+        call string_to_toml(toml, table)
+
+        !> Default object
+        call fortran%load(table,error)
+
+    end subroutine fft_invalid
+
+    !> Test serialization/deserialization of a package_t structure
+    subroutine package_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(package_t) :: pkg
+        integer :: ierr
+
+        !> Default object
+        call pkg%test_serialization('package_t: default object',error)
+        if (allocated(error)) return
+
+        !> Create a dummy package
+        pkg%name = "orderpack"
+        pkg%version = "0.1.0"
+        pkg%enforce_module_names = .false.
+        pkg%module_prefix = string_t("")
+        pkg%features%source_form = "free"
+
+        if (allocated(pkg%sources)) deallocate(pkg%sources)
+        allocate(pkg%sources(4))
+
+        pkg%sources(1)%file_name = "build/dependencies/orderpack/src/M_valnth.f90"
+        pkg%sources(1)%digest = 2662523002405134329_tf_i8
+        pkg%sources(1)%unit_scope = FPM_SCOPE_LIB
+        pkg%sources(1)%unit_type = FPM_UNIT_MODULE
+        pkg%sources(1)%modules_provided = [string_t("m_valnth")]
+        deallocate(pkg%sources(1)%parent_modules, stat=ierr)
+        deallocate(pkg%sources(1)%modules_used, stat=ierr)
+        deallocate(pkg%sources(1)%include_dependencies, stat=ierr)
+        deallocate(pkg%sources(1)%link_libraries, stat=ierr)
+
+        pkg%sources(2)%file_name = "build/dependencies/orderpack/src/M_mrgrnk.f90"
+        pkg%sources(2)%digest = 7985690966656622651_tf_i8
+        pkg%sources(2)%unit_scope = FPM_SCOPE_LIB
+        pkg%sources(2)%unit_type = FPM_UNIT_MODULE
+        pkg%sources(2)%modules_provided = [string_t("m_mrgrnk")]
+        pkg%sources(2)%link_libraries = [string_t("netcdf"),string_t("hdf-5")]
+        deallocate(pkg%sources(2)%parent_modules, stat=ierr)
+        deallocate(pkg%sources(2)%modules_used, stat=ierr)
+        deallocate(pkg%sources(2)%include_dependencies, stat=ierr)
+        deallocate(pkg%sources(2)%link_libraries, stat=ierr)
+
+        pkg%sources(3)%file_name = "build/dependencies/orderpack/src/M_median.f90"
+        pkg%sources(3)%digest = 7985690966656622651_tf_i8
+        pkg%sources(3)%unit_scope = FPM_SCOPE_LIB
+        pkg%sources(3)%unit_type = FPM_UNIT_MODULE
+        pkg%sources(3)%modules_provided = [string_t("m_median")]
+        deallocate(pkg%sources(3)%parent_modules, stat=ierr)
+        deallocate(pkg%sources(3)%modules_used, stat=ierr)
+        deallocate(pkg%sources(3)%include_dependencies, stat=ierr)
+        deallocate(pkg%sources(3)%link_libraries, stat=ierr)
+
+        pkg%sources(4)%file_name = "build/dependencies/orderpack/src/M_unista.f90"
+        pkg%sources(4)%digest = -7512253540457404792_tf_i8
+        pkg%sources(4)%unit_scope = FPM_SCOPE_LIB
+        pkg%sources(4)%unit_type = FPM_UNIT_MODULE
+        pkg%sources(4)%modules_provided = [string_t("m_unista")]
+        pkg%sources(4)%modules_used = [string_t("m_uniinv")]
+        deallocate(pkg%sources(4)%parent_modules, stat=ierr)
+        deallocate(pkg%sources(4)%include_dependencies, stat=ierr)
+        deallocate(pkg%sources(4)%link_libraries, stat=ierr)
+
+        !> Package mock
+        call pkg%test_serialization('package_t: orderpack',error)
+        if (allocated(error)) return
+
+        !> Remove some entries
+        pkg%sources(1)%file_name = ""
+        pkg%sources(3)%digest = 0
+        pkg%sources = pkg%sources(1:3)
+        call pkg%test_serialization('package_t: orderpack (reduced)',error)
+        if (allocated(error)) return
+
+        !> Remove all sources
+        deallocate(pkg%sources,stat=ierr)
+        call pkg%test_serialization('package_t: no sources',error)
+        if (allocated(error)) return
+
+    end subroutine package_roundtrip
+
+    !> Test deserialization of an invalid package TOML file
+    subroutine package_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(len=*), parameter :: toml = &
+            & 'name = "toml-f"  '//NL//&
+            & 'version = "0.8.0"  '//NL//&
+            & 'module-naming = "prefix"  '//NL//& ! this should be boolean
+            & 'module-prefix = ""  '
+
+        type(package_t) :: pkg
+        type(toml_table), allocatable :: table
+
+        call string_to_toml(toml, table)
+
+        !> Default object
+        call pkg%load(table,error)
+
+    end subroutine package_invalid
+
+    !> Test deserialization of an invalid source file
+    subroutine source_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(len=*), parameter :: toml = &
+            & 'file-name = "build/dependencies/toml-f/src/tomlf.f90"  '//NL//&
+            & 'digest = "abcde"  '//NL//& ! not a number
+            & 'unit-scope = "FPM_SCOPE_MODULE"  '//NL//&
+            & 'unit-type = "FPM_UNIT_MODULE"  '//NL//&
+            & 'modules-provided = "tomlf"  '//NL//&
+            & 'parent-modules = [ ]  '//NL//&
+            & 'modules-used = [ "tomlf_build", "tomlf_datetime" ]  '//NL//&
+            & 'include-dependencies = [ ]  '//NL//&
+            & 'link-libraries = [ ]  '
+
+        type(srcfile_t) :: src
+        type(toml_table), allocatable :: table
+
+        call string_to_toml(toml, table)
+
+        !> Default object
+        call src%load(table,error)
+
+    end subroutine source_invalid
+
+    !> Test serialization/deserialization of an archiver_t structure
+    subroutine ar_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(archiver_t) :: ar
+        integer :: ierr
+
+        !> Default object
+        call ar%test_serialization('archiver_t: default object',error)
+        if (allocated(error)) return
+
+        !> change a few items
+        ar%ar = "ar"
+        ar%echo = .true.
+        ar%use_response_file = .false.
+
+        call ar%test_serialization('archiver_t: ar',error)
+
+    end subroutine ar_roundtrip
+
+    !> Test deserialization of an invalid archiver_t structure
+    subroutine ar_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(len=*), parameter :: toml = &
+            & 'ar = "ar -rs "    '//NL//&
+            & 'use-response-file = false    '//NL//&
+            & 'echo = 123     '//NL//& ! not a boolean
+            & 'verbose = false   '
+
+        type(archiver_t) :: ar
+        type(toml_table), allocatable :: table
+
+        call string_to_toml(toml, table)
+
+        !> Default object
+        call ar%load(table,error)
+
+    end subroutine ar_invalid
+
+    !> Test serialization/deserialization of a compiler_t structure
+    subroutine compiler_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(compiler_t) :: compiler
+
+        !> Default object
+        call compiler%test_serialization('compiler_t: default object',error)
+        if (allocated(error)) return
+
+        !> change a few items
+        compiler%id = id_gcc
+        compiler%fc = "gfortran -ffree-line-length-none -fdefault-real-8 -O3"
+        compiler%cc = ""
+        compiler%cxx = "g++ -O3 -std=c++11"
+        compiler%echo = .false.
+
+        call compiler%test_serialization('compiler_t: gcc',error)
+
+    end subroutine compiler_roundtrip
+
+    !> Test deserialization of an invalid compiler_t TOML structure
+    subroutine compiler_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        character(len=*), parameter :: toml = &
+            & 'id = "gfortran"    '//NL//& ! not an integer identifier
+            & 'fc = "gfortran"    '//NL//&
+            & 'cc = "gcc"    '//NL//&
+            & 'cxx = "g++"     '//NL//&
+            & 'echo = false    '//NL//&
+            & 'verbose = false    '
+
+        type(compiler_t) :: cc
+        type(toml_table), allocatable :: table
+
+        call string_to_toml(toml, table)
+
+        !> Default object
+        call cc%load(table,error)
+
+    end subroutine compiler_invalid
+
+    !> Get a shortened TOML representation of the fpm v0.8.1 model
+    subroutine fpm_081_table(table)
+
+        !> TOML representation of the fpm v0.8.1 model
+        type(toml_table), allocatable, intent(out) :: table
+
+        !> simplified TOML representation of the fpm v0.8.1 model
+        character(len=:), allocatable :: fpm
+
+        integer :: iunit
+
+        allocate(character(len=0) :: fpm)
+        fpm = fpm//NL//'package-name = "fpm"'
+        fpm = fpm//NL//'fortran-flags = " -Wall -Wextra -fPIC -fmax-errors=1 -g "'
+        fpm = fpm//NL//'c-flags = ""'
+        fpm = fpm//NL//'cxx-flags = ""'
+        fpm = fpm//NL//'link-flags = ""'
+        fpm = fpm//NL//'build-prefix = "build/gfortran"'
+        fpm = fpm//NL//'include-dirs = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'external-modules = [ ]'
+        fpm = fpm//NL//'include-tests = false'
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+        fpm = fpm//NL//'[compiler]'
+        fpm = fpm//NL//'id = 1'
+        fpm = fpm//NL//'fc = "gfortran"'
+        fpm = fpm//NL//'cc = "gcc"'
+        fpm = fpm//NL//'cxx = "g++"'
+        fpm = fpm//NL//'echo = false'
+        fpm = fpm//NL//'verbose = false'
+        fpm = fpm//NL//'[archiver]'
+        fpm = fpm//NL//'ar = "ar -rs "'
+        fpm = fpm//NL//'use-response-file = false'
+        fpm = fpm//NL//'echo = false'
+        fpm = fpm//NL//'verbose = false'
+        fpm = fpm//NL//'[deps]'
+        fpm = fpm//NL//'unit = 6'
+        fpm = fpm//NL//'verbosity = 1'
+        fpm = fpm//NL//'dep-dir = "build/dependencies"'
+        fpm = fpm//NL//'cache = "build/cache.toml"'
+        fpm = fpm//NL//'ndep = 4'
+        fpm = fpm//NL//'[deps.dependencies]'
+        fpm = fpm//NL//'[deps.dependencies.fpm]'
+        fpm = fpm//NL//'name = "fpm"'
+        fpm = fpm//NL//'path = "."'
+        fpm = fpm//NL//'version = "0.8.0"'
+        fpm = fpm//NL//'proj-dir = "./."'
+        fpm = fpm//NL//'done = true'
+        fpm = fpm//NL//'update = false'
+        fpm = fpm//NL//'cached = false'
+        fpm = fpm//NL//'[deps.dependencies.toml-f]'
+        fpm = fpm//NL//'name = "toml-f"'
+        fpm = fpm//NL//'version = "0.4.0"'
+        fpm = fpm//NL//'proj-dir = "build/dependencies/toml-f"'
+        fpm = fpm//NL//'revision = "54686e45993f3a9a1d05d5c7419f39e7d5a4eb3f"'
+        fpm = fpm//NL//'done = true'
+        fpm = fpm//NL//'update = false'
+        fpm = fpm//NL//'cached = true'
+        fpm = fpm//NL//'[deps.dependencies.toml-f.git]'
+        fpm = fpm//NL//'descriptor = "revision"'
+        fpm = fpm//NL//'url = "https://github.com/toml-f/toml-f"'
+        fpm = fpm//NL//'object = "54686e45993f3a9a1d05d5c7419f39e7d5a4eb3f"'
+        fpm = fpm//NL//'[deps.dependencies.UNNAMED_DEPENDENCY_5]'
+        fpm = fpm//NL//'done = false'
+        fpm = fpm//NL//'update = false'
+        fpm = fpm//NL//'cached = false'
+        fpm = fpm//NL//'[packages]'
+        fpm = fpm//NL//'[packages.fpm]'
+        fpm = fpm//NL//'name = "fpm"'
+        fpm = fpm//NL//'version = "0.8.0"'
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+        fpm = fpm//NL//'[packages.fpm.fortran]'
+        fpm = fpm//NL//'implicit-typing = false'
+        fpm = fpm//NL//'implicit-external = false'
+        fpm = fpm//NL//'source-form = "free"'
+        fpm = fpm//NL//'[packages.fpm.sources]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_1]'
+        fpm = fpm//NL//'file-name = "././src/fpm.f90"'
+        fpm = fpm//NL//'digest = 4322290725857190613'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "fpm"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "fpm_strings", "fpm_backend", "fpm_compiler", "fpm_error" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_2]'
+        fpm = fpm//NL//'file-name = "././src/fpm_backend.F90"'
+        fpm = fpm//NL//'digest = -3210121688944515946'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "fpm_backend"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "fpm_error", "fpm_filesystem", "fpm_backend_output" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_3]'
+        fpm = fpm//NL//'file-name = "././src/fpm_environment.f90"'
+        fpm = fpm//NL//'digest = 2235607720245152632'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "fpm_environment"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = "fpm_error"'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_4]'
+        fpm = fpm//NL//'file-name = "././src/fpm_model.f90"'
+        fpm = fpm//NL//'digest = -6774177234665080583'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "fpm_model"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "fpm_compiler", "fpm_dependency" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_5]'
+        fpm = fpm//NL//'file-name = "././src/filesystem_utilities.c"'
+        fpm = fpm//NL//'digest = 4957633104775755438'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_CSOURCE"'
+        fpm = fpm//NL//'modules-provided = [ ]'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.fpm.sources.src_59]'
+        fpm = fpm//NL//'file-name = "test/new_test/new_test.f90"'
+        fpm = fpm//NL//'exe-name = "new-test"'
+        fpm = fpm//NL//'digest = 4683353150944180202'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_TEST"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_PROGRAM"'
+        fpm = fpm//NL//'modules-provided = [ ]'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "fpm_filesystem", "fpm_strings", "fpm_environment" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.toml-f]'
+        fpm = fpm//NL//'name = "toml-f"'
+        fpm = fpm//NL//'version = "0.8.0"'
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+        fpm = fpm//NL//'[packages.toml-f.fortran]'
+        fpm = fpm//NL//'implicit-typing = false'
+        fpm = fpm//NL//'implicit-external = false'
+        fpm = fpm//NL//'source-form = "free"'
+        fpm = fpm//NL//'[packages.toml-f.sources]'
+        fpm = fpm//NL//'[packages.toml-f.sources.src_1]'
+        fpm = fpm//NL//'file-name = "build/dependencies/toml-f/src/tomlf.f90"'
+        fpm = fpm//NL//'digest = -8299830903248890534'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "tomlf"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "tomlf_build", "tomlf_datetime" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.toml-f.sources.src_2]'
+        fpm = fpm//NL//'file-name = "build/dependencies/toml-f/src/tomlf/constants.f90"'
+        fpm = fpm//NL//'digest = 7170350792708576173'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "tomlf_constants"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.M_CLI2]'
+        fpm = fpm//NL//'name = "M_CLI2"'
+        fpm = fpm//NL//'version = "0.8.0"'
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+        fpm = fpm//NL//'[packages.M_CLI2.fortran]'
+        fpm = fpm//NL//'implicit-typing = false'
+        fpm = fpm//NL//'implicit-external = false'
+        fpm = fpm//NL//'source-form = "free"'
+        fpm = fpm//NL//'[packages.M_CLI2.sources]'
+        fpm = fpm//NL//'[packages.M_CLI2.sources.src_1]'
+        fpm = fpm//NL//'file-name = "build/dependencies/M_CLI2/src/M_CLI2.F90"'
+        fpm = fpm//NL//'digest = -6169834068995303802'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "m_cli2"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.jonquil]'
+        fpm = fpm//NL//'name = "jonquil"'
+        fpm = fpm//NL//'version = "0.8.0"'
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+        fpm = fpm//NL//'[packages.jonquil.fortran]'
+        fpm = fpm//NL//'implicit-typing = false'
+        fpm = fpm//NL//'implicit-external = false'
+        fpm = fpm//NL//'source-form = "free"'
+        fpm = fpm//NL//'[packages.jonquil.sources]'
+        fpm = fpm//NL//'[packages.jonquil.sources.src_1]'
+        fpm = fpm//NL//'file-name = "build/dependencies/jonquil/src/jonquil.f90"'
+        fpm = fpm//NL//'digest = 5552073973512025871'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "jonquil"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ "tomlf", "tomlf_type", "jonquil_ser" ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'[packages.jonquil.sources.src_2]'
+        fpm = fpm//NL//'file-name = "build/dependencies/jonquil/src/jonquil/version.f90"'
+        fpm = fpm//NL//'digest = -2934903401983932826'
+        fpm = fpm//NL//'unit-scope = "FPM_SCOPE_LIB"'
+        fpm = fpm//NL//'unit-type = "FPM_UNIT_MODULE"'
+        fpm = fpm//NL//'modules-provided = "jonquil_version"'
+        fpm = fpm//NL//'parent-modules = [ ]'
+        fpm = fpm//NL//'modules-used = [ ]'
+        fpm = fpm//NL//'include-dependencies = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+
+        call string_to_toml(fpm, table)
+
+    end subroutine fpm_081_table
+
+    !> Convert a character string to a TOML table
+    subroutine string_to_toml(string, table)
+
+        !> The input TOML as a string
+        character(*), intent(in) :: string
+
+        !> The TOML table
+        type(toml_table), allocatable, intent(out) :: table
+
+        integer :: iunit
+
+        ! Write
+        open(newunit=iunit,form='formatted',status='scratch',action='readwrite')
+
+        !> Dump to scratch file
+        write(iunit,*) string
+
+        !> Load from scratch file
+        rewind(iunit)
+        call toml_load(table, iunit)
+
+        close(iunit)
+
+    end subroutine string_to_toml
+
+    subroutine fpm_model_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+        type(fpm_model_t) :: model
+        type(toml_table), allocatable :: table
+
+        call model%test_serialization('fpm_model_t: default object', error)
+        if (allocated(error)) return
+
+        !> Now init form fpm 0.8.1 table
+        call fpm_081_table(table)
+
+        call model%load(table, error)
+        if (allocated(error)) then
+            call fatal_error(error, 'fpm_model_t: cannot load model from fpm v0.8.1 TOML')
+            return
+        end if
+
+        call model%test_serialization('fpm_model_t: fpm v0.8.1 model test', error)
+
+    end subroutine fpm_model_roundtrip
+
+
+    subroutine fpm_model_invalid(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(fpm_model_t) :: model
+        type(toml_table), allocatable :: table
+        character(len=:), allocatable :: fpm
+
+        allocate(character(len=0) :: fpm)
+        fpm = fpm//NL//'package-name = "fpm"'
+        fpm = fpm//NL//'fortran-flags = " -Wall -Wextra -fPIC -fmax-errors=1 -g "'
+        fpm = fpm//NL//'c-flags = ""'
+        fpm = fpm//NL//'cxx-flags = ""'
+        fpm = fpm//NL//'link-flags = ""'
+        fpm = fpm//NL//'build-prefix = "build/gfortran"'
+        fpm = fpm//NL//'include-dirs = [ ]'
+        fpm = fpm//NL//'link-libraries = [ ]'
+        fpm = fpm//NL//'external-modules = "" '
+        fpm = fpm//NL//'include-tests = "my_test"' ! not a boolean
+        fpm = fpm//NL//'module-naming = false'
+        fpm = fpm//NL//'module-prefix = ""'
+
+        call string_to_toml(fpm, table)
+        call model%load(table,error)
+
+    end subroutine fpm_model_invalid
+
+    subroutine install_config_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(install_config_t) :: install
+
+        integer :: loop
+
+        do loop=1,2
+
+           install % library = mod(loop,2)==0
+
+            ! Test full object
+            call install%test_serialization('install_config_roundtrip',error)
+            if (allocated(error)) return
+
+        end do
+
+    end subroutine install_config_roundtrip
+
+    subroutine fortran_features_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(fortran_config_t) :: fortran
+
+        fortran%implicit_external = .true.
+        fortran%implicit_typing = .false.
+        fortran%source_form = 'free'
+
+        call fortran%test_serialization('fortran_features_roundtrip',error)
+        if (allocated(error)) return
+
+        deallocate(fortran%source_form)
+        call fortran%test_serialization('fortran_features_roundtrip 2',error)
+
+    end subroutine fortran_features_roundtrip
+
+    subroutine library_config_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(library_config_t) :: lib
+
+        lib%source_dir = 'lib'
+        lib%include_dir = [string_t('a'),string_t('b')]
+
+        call lib%test_serialization('library_config: 1',error)
+        if (allocated(error)) return
+
+        lib%build_script = 'install.sh'
+
+        call lib%test_serialization('library_config: 2',error)
+        if (allocated(error)) return
+
+        deallocate(lib%include_dir)
+        call lib%test_serialization('library_config: 3',error)
+
+    end subroutine library_config_roundtrip
+
+
+    subroutine executable_config_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(executable_config_t) :: exe
+        type(dependency_config_t) :: dep
+
+        exe%name = "my_executable"
+        exe%source_dir = 'app'
+
+        call exe%test_serialization('executable_config: 1',error)
+        if (allocated(error)) return
+
+        exe%main = 'main_program.F90'
+
+        call exe%test_serialization('executable_config: 2',error)
+        if (allocated(error)) return
+
+        exe%link = [string_t('netcdf'),string_t('hdf5')]
+        call exe%test_serialization('executable_config: 3',error)
+
+        call dependency_destroy(dep)
+
+        dep%name = "M_CLI2"
+        dep%path = "~/./some/dummy/path"
+        dep%namespace = "urbanjost"
+        allocate(dep%requested_version)
+        call new_version(dep%requested_version, "3.2.0",error); if (allocated(error)) return
+
+        allocate(dep%git)
+        dep%git = git_target_revision(url="https://github.com/urbanjost/M_CLI2.git", &
+                                      sha1="7264878cdb1baff7323cc48596d829ccfe7751b8")
+
+        allocate(exe%dependency(1),source=dep)
+        call exe%test_serialization('executable_config: 4',error)
+
+    end subroutine executable_config_roundtrip
+
+
+    subroutine preprocess_config_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(preprocess_config_t) :: prep
+
+        prep%name = "preprocessor config"
+        prep%macros = [string_t('Whatever'),string_t('FPM_BOOTSTRAP')]
+
+        call prep%test_serialization('preprocess_config', error)
+
+    end subroutine preprocess_config_roundtrip
+
+    subroutine file_scope_flag_roundtrip(error)
+
+        !> Error handling
+        type(error_t), allocatable, intent(out) :: error
+
+        type(file_scope_flag) :: ff
+
+        call ff%test_serialization('file_scope_flag: empty', error)
+        if (allocated(error)) return
+
+        ff%file_name = "preprocessor config"
+        ff%flags = "-1 -f -2 -g"
+
+        call ff%test_serialization('file_scope_flag: non-empty', error)
+
+    end subroutine file_scope_flag_roundtrip
 
 end module test_toml