diff --git a/.github/workflows/cpuarch.yml b/.github/workflows/cpuarch.yml
index 672d26395..56184e035 100644
--- a/.github/workflows/cpuarch.yml
+++ b/.github/workflows/cpuarch.yml
@@ -2,6 +2,8 @@ name: CPU Compilation/Unit Tests
 
 on:
   push:
+  pull_request:
+    types: [ready_for_review] 
 
 jobs:
   check-commit:
@@ -14,6 +16,10 @@ jobs:
       - name: Check commit message
         id: check_message
         run: |
+          if [[ "${{ github.event_name }}" == "pull_request" && "${{ github.event.action }}" == "ready_for_review" ]]; then
+            echo "run_tests=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
           if git log -1 --pretty=%B | grep -q "CPUTEST"; then
             echo "run_tests=true" >> "$GITHUB_OUTPUT"
           else
diff --git a/.gitmodules b/.gitmodules
index 835fbe5b8..f66f13275 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,3 @@
-[submodule "extern/plog"]
-	path = extern/plog
-	url = https://github.com/SergiusTheBest/plog.git
 [submodule "extern/adios2"]
 	path = extern/adios2
 	url = https://github.com/ornladios/ADIOS2.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fad95b106..985eebc53 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ set(PROJECT_NAME entity)
 
 project(
   ${PROJECT_NAME}
-  VERSION 1.3.3
+  VERSION 1.4.0
   LANGUAGES CXX C)
 add_compile_options("-D ENTITY_VERSION=\"${PROJECT_VERSION}\"")
 set(hash_cmd "git diff --quiet src/ && echo $(git rev-parse HEAD) ")
@@ -47,9 +47,6 @@ set(pgen
     ${default_pgen}
     CACHE STRING "Problem generator")
 
-set(gui
-    ${default_gui}
-    CACHE BOOL "Use GUI [nttiny]")
 set(output
     ${default_output}
     CACHE BOOL "Enable output")
@@ -62,7 +59,7 @@ set(gpu_aware_mpi
     CACHE BOOL "Enable GPU-aware MPI")
 
 # -------------------------- Compilation settings -------------------------- #
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
@@ -70,7 +67,7 @@ if(${DEBUG} STREQUAL "OFF")
   set(CMAKE_BUILD_TYPE
       Release
       CACHE STRING "CMake build type")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG -O3")
 else()
   set(CMAKE_BUILD_TYPE
       Debug
@@ -109,9 +106,8 @@ set(BUILD_TESTING
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/dependencies.cmake)
 
 find_or_fetch_dependency(Kokkos FALSE QUIET)
-find_or_fetch_dependency(plog TRUE QUIET)
 set(DEPENDENCIES Kokkos::kokkos)
-include_directories(${plog_SRC}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 # -------------------------------- Main code ------------------------------- #
 set_precision(${precision})
@@ -162,29 +158,37 @@ if(${output})
   find_or_fetch_dependency(adios2 FALSE QUIET)
   add_compile_options("-D OUTPUT_ENABLED")
   if(${mpi})
-    set(DEPENDENCIES ${DEPENDENCIES} adios2::cxx11_mpi)
+    set(DEPENDENCIES ${DEPENDENCIES} adios2::cxx_mpi)
   else()
-    set(DEPENDENCIES ${DEPENDENCIES} adios2::cxx11)
+    set(DEPENDENCIES ${DEPENDENCIES} adios2::cxx)
   endif()
 endif()
 
 link_libraries(${DEPENDENCIES})
 
+set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/)
+add_subdirectory(${SRC_DIR}/global ${CMAKE_CURRENT_BINARY_DIR}/global)
+add_subdirectory(${SRC_DIR}/metrics ${CMAKE_CURRENT_BINARY_DIR}/metrics)
+add_subdirectory(${SRC_DIR}/kernels ${CMAKE_CURRENT_BINARY_DIR}/kernels)
+add_subdirectory(${SRC_DIR}/archetypes ${CMAKE_CURRENT_BINARY_DIR}/archetypes)
+add_subdirectory(${SRC_DIR}/framework ${CMAKE_CURRENT_BINARY_DIR}/framework)
+add_subdirectory(${SRC_DIR}/output ${CMAKE_CURRENT_BINARY_DIR}/output)
+
+# ------------------------------- Main source ------------------------------ #
+if(NOT ${pgen} STREQUAL ${default_pgen})
+  set_problem_generator(${pgen})
+  add_subdirectory(${SRC_DIR}/engines ${CMAKE_CURRENT_BINARY_DIR}/engines)
+  add_subdirectory(${SRC_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src)
+endif()
+
 if(TESTS)
   # ---------------------------------- Tests --------------------------------- #
   include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/tests.cmake)
-elseif(BENCHMARK)
+endif()
+
+if(BENCHMARK)
   # ------------------------------ Benchmark --------------------------------- #
   include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/benchmark.cmake)
-else()
-  # ----------------------------------- GUI ---------------------------------- #
-  if(${gui})
-    find_or_fetch_dependency(nttiny FALSE QUIET)
-  endif()
-
-  # ------------------------------- Main source ------------------------------ #
-  set_problem_generator(${pgen})
-  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src src)
 endif()
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/report.cmake)
diff --git a/README.md b/README.md
index 41d5ae280..72fc3a1f1 100644
--- a/README.md
+++ b/README.md
@@ -37,8 +37,8 @@ Maintainers indicated with an arrow.
 * :tipping_hand_person: Alexander Chernoglazov {[@SChernoglazov](https://github.com/SChernoglazov)}
 * :tea: Benjamin Crinquand {[@bcrinquand](https://github.com/bcrinquand)}
 * :bubble_tea: Alisa Galishnikova {[@alisagk](https://github.com/alisagk)}
-* :steam_locomotive: Evgeny Gorbunov {[@Alcauchy](https://github.com/Alcauchy)} [-> [haykh.astro [at] gmail](mailto:haykh.astro@gmail.com)]
-* :coffee: Hayk Hakobyan {[@haykh](https://github.com/haykh)} [-> [genegorbs [at] gmail](mailto:genegorbs@gmail.com)]
+* :steam_locomotive: Evgeny Gorbunov {[@Alcauchy](https://github.com/Alcauchy)} [-> [genegorbs [at] gmail](mailto:genegorbs@gmail.com)]
+* :coffee: Hayk Hakobyan {[@haykh](https://github.com/haykh)} [-> [haykh.astro [at] gmail](mailto:haykh.astro@gmail.com)]
 * :potato: Jens Mahlmann {[@jmahlmann](https://github.com/jmahlmann)}
 * :dolphin: Sasha Philippov {[@sashaph](https://github.com/sashaph)}
 * :radio: Siddhant Solanki {[@sidruns30](https://github.com/sidruns30)}
diff --git a/cmake/benchmark.cmake b/cmake/benchmark.cmake
index fdd8438ea..af0d334ea 100644
--- a/cmake/benchmark.cmake
+++ b/cmake/benchmark.cmake
@@ -2,17 +2,6 @@
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
-add_subdirectory(${SRC_DIR}/global ${CMAKE_CURRENT_BINARY_DIR}/global)
-add_subdirectory(${SRC_DIR}/metrics ${CMAKE_CURRENT_BINARY_DIR}/metrics)
-add_subdirectory(${SRC_DIR}/kernels ${CMAKE_CURRENT_BINARY_DIR}/kernels)
-add_subdirectory(${SRC_DIR}/archetypes ${CMAKE_CURRENT_BINARY_DIR}/archetypes)
-add_subdirectory(${SRC_DIR}/framework ${CMAKE_CURRENT_BINARY_DIR}/framework)
-
-if(${output})
-  add_subdirectory(${SRC_DIR}/output ${CMAKE_CURRENT_BINARY_DIR}/output)
-  add_subdirectory(${SRC_DIR}/checkpoint ${CMAKE_CURRENT_BINARY_DIR}/checkpoint)
-endif()
-
 set(exec benchmark.xc)
 set(src ${CMAKE_CURRENT_SOURCE_DIR}/benchmark/benchmark.cpp)
 
@@ -23,4 +12,7 @@ if(${output})
   list(APPEND libs ntt_output)
 endif()
 add_dependencies(${exec} ${libs})
-target_link_libraries(${exec} PRIVATE ${libs} stdc++fs)
+if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+  list(APPEND libs stdc++fs)
+endif()
+target_link_libraries(${exec} PRIVATE ${libs})
diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake
index 1f3ed3c6a..2024702b5 100644
--- a/cmake/dependencies.cmake
+++ b/cmake/dependencies.cmake
@@ -3,14 +3,24 @@
 set(Kokkos_REPOSITORY
     https://github.com/kokkos/kokkos.git
     CACHE STRING "Kokkos repository")
-set(plog_REPOSITORY
-    https://github.com/SergiusTheBest/plog.git
-    CACHE STRING "plog repository")
+set(Kokkos_TAG
+    5.0.1
+    CACHE STRING "Kokkos tag")
 set(adios2_REPOSITORY
     https://github.com/ornladios/ADIOS2.git
     CACHE STRING "ADIOS2 repository")
+set(adios2_TAG
+    v2.11.0
+    CACHE STRING "ADIOS2 tag")
+
+set(CONNECTION_CHECKED
+    FALSE
+    CACHE BOOL "Whether internet connection has been checked")
 
 function(check_internet_connection)
+  if(CONNECTION_CHECKED)
+    return()
+  endif()
   if(OFFLINE STREQUAL "ON")
     set(FETCHCONTENT_FULLY_DISCONNECTED
         ON
@@ -35,6 +45,9 @@ function(check_internet_connection)
       message(STATUS "${Green}Internet connection established.${ColorReset}")
     endif()
   endif()
+  set(CONNECTION_CHECKED
+      TRUE
+      CACHE BOOL "Whether internet connection has been checked")
 endfunction()
 
 function(find_or_fetch_dependency package_name header_only mode)
@@ -43,6 +56,8 @@ function(find_or_fetch_dependency package_name header_only mode)
   endif()
 
   if(NOT ${package_name}_FOUND)
+    check_internet_connection()
+
     if(${package_name} STREQUAL "Kokkos")
       include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/kokkosConfig.cmake)
     elseif(${package_name} STREQUAL "adios2")
@@ -54,16 +69,11 @@ function(find_or_fetch_dependency package_name header_only mode)
       message(STATUS "${Blue}${package_name} not found. "
                      "Fetching from ${${package_name}_REPOSITORY}${ColorReset}")
       include(FetchContent)
-      if(${package_name} STREQUAL "Kokkos")
+      if(${package_name} STREQUAL "Kokkos" OR ${package_name} STREQUAL "adios2")
         FetchContent_Declare(
           ${package_name}
           GIT_REPOSITORY ${${package_name}_REPOSITORY}
-          GIT_TAG 4.7.01)
-      elseif(${package_name} STREQUAL "adios2")
-        FetchContent_Declare(
-          ${package_name}
-          GIT_REPOSITORY ${${package_name}_REPOSITORY}
-          GIT_TAG v2.10.2)
+          GIT_TAG ${${package_name}_TAG})
       else()
         FetchContent_Declare(${package_name}
                              GIT_REPOSITORY ${${package_name}_REPOSITORY})
@@ -171,5 +181,3 @@ function(find_or_fetch_dependency package_name header_only mode)
       ${${package_name}_BUILD_DIR}
       PARENT_SCOPE)
 endfunction()
-
-check_internet_connection()
diff --git a/cmake/report.cmake b/cmake/report.cmake
index 8f62ac17b..0fbd072cf 100644
--- a/cmake/report.cmake
+++ b/cmake/report.cmake
@@ -8,7 +8,9 @@ if(${PGEN_FOUND})
     "${Blue}"
     PGEN_REPORT
     0)
-elseif(${TESTS})
+endif()
+
+if(${TESTS})
   set(TEST_NAMES "")
   foreach(test_dir IN LISTS TEST_DIRECTORIES)
     get_property(
@@ -18,14 +20,38 @@ elseif(${TESTS})
     list(APPEND TEST_NAMES ${LOCAL_TEST_NAMES})
   endforeach()
   printchoices(
-    "Test cases"
+    "Tests"
+    "TESTS"
+    "${ON_OFF_VALUES}"
+    "ON"
+    "OFF"
+    "${Green}"
+    TESTS_REPORT_1
+    46)
+  printchoices(
+    ""
     ""
     "${TEST_NAMES}"
     ""
     "${ColorReset}"
     ""
-    TESTS_REPORT
+    TESTS_REPORT_2
     0)
+  # remove only first line of TESTS_REPORT_2
+  string(REPLACE "\n" ";" TESTS_REPORT_2_LIST "${TESTS_REPORT_2}")
+  list(REMOVE_AT TESTS_REPORT_2_LIST 0)
+  string(REPLACE ";" "\n" TESTS_REPORT_2 "${TESTS_REPORT_2_LIST}")
+  set(TESTS_REPORT "${TESTS_REPORT_1}\n${TESTS_REPORT_2}")
+else()
+  printchoices(
+    "Tests"
+    "TESTS"
+    "${ON_OFF_VALUES}"
+    "OFF"
+    "OFF"
+    "${Green}"
+    TESTS_REPORT
+    46)
 endif()
 
 printchoices(
@@ -120,9 +146,8 @@ string(APPEND REPORT_TEXT ${DASHED_LINE_SYMBOL} "\n" "Configurations" "\n")
 
 if(${PGEN_FOUND})
   string(APPEND REPORT_TEXT "  " ${PGEN_REPORT} "\n")
-elseif(${TESTS})
-  string(APPEND REPORT_TEXT "  " ${TESTS_REPORT} "\n")
 endif()
+string(APPEND REPORT_TEXT "  " ${TESTS_REPORT} "\n")
 
 string(
   APPEND
diff --git a/cmake/tests.cmake b/cmake/tests.cmake
index 0eb043f70..44bbce444 100644
--- a/cmake/tests.cmake
+++ b/cmake/tests.cmake
@@ -3,13 +3,6 @@ enable_testing()
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 
-add_subdirectory(${SRC_DIR}/global ${CMAKE_CURRENT_BINARY_DIR}/global)
-add_subdirectory(${SRC_DIR}/metrics ${CMAKE_CURRENT_BINARY_DIR}/metrics)
-add_subdirectory(${SRC_DIR}/kernels ${CMAKE_CURRENT_BINARY_DIR}/kernels)
-add_subdirectory(${SRC_DIR}/archetypes ${CMAKE_CURRENT_BINARY_DIR}/archetypes)
-add_subdirectory(${SRC_DIR}/framework ${CMAKE_CURRENT_BINARY_DIR}/framework)
-add_subdirectory(${SRC_DIR}/output ${CMAKE_CURRENT_BINARY_DIR}/output)
-
 set(TEST_DIRECTORIES "")
 
 if(NOT ${mpi})
diff --git a/dependencies.py b/dependencies.py
new file mode 100755
index 000000000..6354b1334
--- /dev/null
+++ b/dependencies.py
@@ -0,0 +1,1178 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import curses
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional, Tuple
+
+
+# ============================
+# colors: edit these
+# ============================
+
+# foreground colors (use curses.COLOR_* or -1 for default)
+COLOR_TITLE_FG = curses.COLOR_BLUE
+COLOR_TEXT_FG = curses.COLOR_WHITE
+COLOR_SELECTED_FG = curses.COLOR_WHITE
+COLOR_SELECTED_BG = curses.COLOR_BLACK
+COLOR_HINT_FG = curses.COLOR_YELLOW
+COLOR_OK_FG = curses.COLOR_GREEN
+COLOR_ERR_FG = curses.COLOR_RED
+COLOR_KEY_FG = curses.COLOR_MAGENTA
+COLOR_DIM_FG = curses.COLOR_CYAN
+
+# pair IDs (must be unique small ints)
+PAIR_TITLE = 1
+PAIR_TEXT = 2
+PAIR_SELECTED = 3
+PAIR_HINT = 4
+PAIR_OK = 5
+PAIR_ERR = 6
+PAIR_KEY = 7
+PAIR_DIM = 8
+
+
+KOKKOS_BACKENDS = ["cpu", "cuda", "hip", "sycl"]
+ADIOS2_MPI_MODES = ["non-mpi", "mpi"]
+
+MESSAGE: str = ""
+
+
+@dataclass
+class Settings:
+    cluster: str = "(custom)"
+    write_modulefiles: bool = False
+    overwrite: bool = False
+    install_prefix: str = os.path.join(os.path.expanduser("~"), ".entity")
+
+    apps: dict = field(
+        default_factory=lambda: {"Kokkos": False, "adios2": False, "nt2py": False}
+    )
+
+    # versions
+    kokkos_version: str = "5.0.1"
+    adios2_version: str = "2.11.0"
+
+    # options
+    kokkos_backend: str = "cpu"
+    kokkos_arch: str = ""
+    extra_kokkos_flags: List[str] = field(default_factory=list)
+    adios2_mpi: str = "non-mpi"
+    extra_adios2_flags: List[str] = field(default_factory=list)
+
+    module_loads: List[str] = field(default_factory=list)
+
+    def from_json(self, json_str: str) -> None:
+        data = json.loads(json_str)
+        self.cluster = data.get("cluster", self.cluster)
+        self.write_modulefiles = data.get("write_modulefiles", self.write_modulefiles)
+        self.overwrite = data.get("overwrite", self.overwrite)
+        self.install_prefix = data.get("install_prefix", self.install_prefix)
+        self.apps = data.get("dependencies", self.apps)
+        versions = data.get("versions", {})
+        self.kokkos_version = versions.get("Kokkos", self.kokkos_version)
+        self.adios2_version = versions.get("adios2", self.adios2_version)
+        options = data.get("options", {})
+        self.kokkos_backend = options.get("kokkos_backend", self.kokkos_backend)
+        self.kokkos_arch = options.get("kokkos_arch", self.kokkos_arch)
+        self.adios2_mpi = options.get("adios2_mpi", self.adios2_mpi)
+        self.module_loads = data.get("module_loads", self.module_loads)
+
+    def apps_summary(self) -> str:
+        chosen = [k for k, v in self.apps.items() if v]
+        return ", ".join(chosen) if chosen else "(none)"
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "cluster": self.cluster,
+                "write_modulefiles": self.write_modulefiles,
+                "overwrite": self.overwrite,
+                "install_prefix": self.install_prefix,
+                "dependencies": self.apps,
+                "versions": {
+                    "Kokkos": self.kokkos_version,
+                    "adios2": self.adios2_version,
+                },
+                "options": {
+                    "kokkos_backend": self.kokkos_backend,
+                    "kokkos_arch": self.kokkos_arch,
+                    "adios2_mpi": self.adios2_mpi,
+                },
+                "module_loads": self.module_loads,
+            },
+            indent=2,
+        )
+
+
+def unindent(script: str) -> str:
+    script_lines = script.splitlines()
+    min_indent = min(
+        (len(line) - len(line.lstrip()) for line in script_lines if line.strip()),
+        default=0,
+    )
+    trimmed_lines = [line[min_indent:] for line in script_lines]
+    if trimmed_lines[0] == "":
+        trimmed_lines = trimmed_lines[1:]
+    if trimmed_lines[-1] == "":
+        trimmed_lines = trimmed_lines[:-1]
+    return "\n".join(trimmed_lines)
+
+
+def InstallKokkosScriptModfile(settings: Settings) -> tuple[str, str]:
+    if settings.apps.get("Kokkos", False):
+        prefix = settings.install_prefix
+        version = settings.kokkos_version
+        backend = settings.kokkos_backend
+        arch = settings.kokkos_arch.strip()
+        modules = "\n".join(
+            [f"module load {module} && \\" for module in settings.module_loads]
+        )
+        src_path = f"{prefix}/src/kokkos"
+        install_path = (
+            f"{prefix}/kokkos/{version}/{backend}{f'_{arch}' if arch else ''}"
+        )
+        if os.path.exists(install_path) and not settings.overwrite:
+            raise FileExistsError(
+                f"Kokkos install path {install_path} already exists and overwrite is disabled"
+            )
+
+        extra_flags = "-D ".join(settings.extra_kokkos_flags)
+        cxx_standard = 20 if tuple(map(int, version.split("."))) >= (5, 0, 0) else 17
+
+        if arch == "":
+            arch = "NATIVE"
+        arch = arch.upper()
+
+        script = f"""
+        # Kokkos installation
+        {modules}
+        rm -rf {src_path} && \\
+        git clone https://github.com/kokkos/kokkos.git {src_path} && \\
+        cd {src_path} && \\
+        git checkout {version} && \\
+        cmake -B build \\
+            -D CMAKE_CXX_STANDARD={cxx_standard} \\
+            -D CMAKE_CXX_EXTENSIONS=OFF \\
+            -D CMAKE_POSITION_INDEPENDENT_CODE=TRUE \\
+            -D Kokkos_ARCH_{arch}=ON {f'-D Kokkos_ENABLE_{backend.upper()}=ON' if backend != 'cpu' else ''} \\
+            -D CMAKE_INSTALL_PREFIX={install_path} {extra_flags} && \\
+        cmake --build build -j $(nproc) && \\
+        cmake --install build
+        """
+
+        modfile = f"""
+        #%Module1.0######################################################################
+        ##
+        ## Kokkos @ {backend} @ {arch} modulefile
+        ##
+        #################################################################################
+        proc ModulesHelp {{ }} {{
+            puts stderr \"\\tKokkos @ {backend} @ {arch}\\n\"
+        }}
+
+        module-whatis      \"Sets up Kokkos @ {backend} @ {arch}\"
+
+        conflict           kokkos
+        {modules}
+
+        set                basedir      {install_path}
+        prepend-path       PATH         $basedir/bin
+        setenv             Kokkos_DIR   $basedir
+
+        setenv Kokkos_ARCH_{arch} ON
+        {f'setenv Kokkos_ENABLE_{backend.upper()} ON' if backend != 'cpu' else ''}
+        """
+
+        return (unindent(script), unindent(modfile))
+
+    else:
+        return ("""# skipping Kokkos install""", "")
+
+
+def InstallAdios2Script(settings: Settings) -> tuple[str, str]:
+    if settings.apps.get("adios2", False):
+        prefix = settings.install_prefix
+        version = settings.adios2_version
+        mpi_mode = settings.adios2_mpi
+        modules = "\n".join(
+            [f"module load {module} && \\" for module in settings.module_loads]
+        )
+        src_path = f"{prefix}/src/adios2"
+        install_path = f"{prefix}/adios2/{version}/{mpi_mode}"
+        if os.path.exists(install_path) and not settings.overwrite:
+            raise FileExistsError(
+                f"Adios2 install path {install_path} already exists and overwrite is disabled"
+            )
+
+        extra_flags = "-D ".join(settings.extra_adios2_flags)
+        cxx_standard = (
+            20
+            if tuple(map(int, settings.kokkos_version.split("."))) >= (5, 0, 0)
+            else 17
+        )
+
+        with_mpi = "ON" if mpi_mode == "mpi" else "OFF"
+
+        script = f"""
+        # Adios2 installation
+        {modules}
+        rm -rf {src_path} && \\
+        git clone https://github.com/ornladios/ADIOS2.git {src_path} && \\
+        cd {src_path} && \\
+        git checkout v{version} && \\
+        cmake -B build \\
+            -D CMAKE_CXX_STANDARD={cxx_standard} \\
+            -D CMAKE_CXX_EXTENSIONS=OFF \\
+            -D CMAKE_POSITION_INDEPENDENT_CODE=TRUE \\
+            -D BUILD_SHARED_LIBS=ON \\
+            -D ADIOS2_USE_Python=OFF \\
+            -D ADIOS2_USE_Fortran=OFF \\
+            -D ADIOS2_USE_ZeroMQ=OFF \\
+            -D BUILD_TESTING=OFF \\
+            -D ADIOS2_BUILD_EXAMPLES=OFF \\
+            -D ADIOS2_USE_HDF5=OFF \\
+            -D ADIOS2_USE_MPI={with_mpi} \\
+            -D CMAKE_INSTALL_PREFIX={install_path} {extra_flags} && \\
+        cmake --build build -j $(nproc) && \\
+        cmake --install build
+        """
+
+        modfile = f"""
+        #%Module1.0######################################################################
+        ##
+        ## ADIOS2 @ {mpi_mode} modulefile
+        ##
+        #################################################################################
+        proc ModulesHelp {{ }} {{
+            puts stderr \"\\tADIOS2 @ {mpi_mode}\\n\"
+        }}
+
+        module-whatis      \"Sets up ADIOS2 @ {mpi_mode}\"    
+
+        conflict           adios2
+        {modules}
+
+        set                basedir      {install_path}
+        prepend-path       PATH         $basedir/bin
+        setenv             ADIOS2_DIR   $basedir
+
+        setenv ADIOS2_USE_MPI {with_mpi}
+        """
+
+        return (unindent(script), unindent(modfile))
+
+    else:
+        return ("""# skipping Adios2 install""", "")
+
+
+def InstallNt2pyScript(settings: Settings) -> str:
+    if settings.apps.get("nt2py", False):
+        prefix = settings.install_prefix
+        modules = "\n".join(
+            [f"module load {module} && \\" for module in settings.module_loads]
+        )
+        install_path = f"{prefix}/.venv"
+
+        script = f"""
+        # nt2py installation
+        {modules}
+        rm -rf {install_path} && \\
+        python3 -m venv {install_path} && \\
+        source {install_path}/bin/activate && \\
+        pip install nt2py && \\
+        deactivate
+        """
+        return unindent(script)
+    else:
+        return """# skipping nt2py install"""
+
+
+PRESETS = {
+    "rusty": {"module_loads": []},
+    "stellar": {"module_loads": []},
+    "perlmutter": {"module_loads": []},
+    "frontier": {"module_loads": []},
+    "aurora": {"module_loads": []},
+}
+
+
+def apply_preset(s: Settings, name: str) -> None:
+    s.cluster = name
+    s.install_prefix = os.path.join(os.path.expanduser("~"), ".entity")
+    cluster_preset = PRESETS.get(name, {})
+    s.apps["Kokkos"] = True
+    s.apps["adios2"] = True
+    s.apps["nt2py"] = True
+    s.module_loads = cluster_preset.get("module_loads", [])
+    s.extra_kokkos_flags = cluster_preset.get("extra_kokkos_flags", [])
+    s.extra_adios2_flags = cluster_preset.get("extra_adios2_flags", [])
+
+
+def on_install_confirmed(settings: Settings) -> None:
+    global MESSAGE
+    os.makedirs(settings.install_prefix, exist_ok=True)
+    kokkos_script, kokkos_modfile = InstallKokkosScriptModfile(settings)
+    adios2_script, adios2_modfile = InstallAdios2Script(settings)
+    with open(os.path.join(settings.install_prefix, "install.sh"), "w") as f:
+        f.write("#!/usr/bin/env bash\n\n")
+        f.write(kokkos_script)
+        f.write("\n\n")
+        f.write(adios2_script)
+        f.write("\n")
+    if settings.write_modulefiles:
+        os.makedirs(os.path.join(settings.install_prefix, "modules"), exist_ok=True)
+        if kokkos_modfile != "":
+            kokkos_modfile_file = os.path.join(
+                settings.install_prefix,
+                "modules",
+                "kokkos",
+                settings.kokkos_backend
+                + (
+                    f"_{settings.kokkos_arch.strip()}"
+                    if settings.kokkos_arch.strip()
+                    else ""
+                ),
+                settings.kokkos_version,
+            )
+            os.makedirs(os.path.dirname(kokkos_modfile_file), exist_ok=True)
+            if os.path.exists(kokkos_modfile_file) and not settings.overwrite:
+                raise FileExistsError(
+                    f"modulefile {kokkos_modfile_file} already exists and overwrite is disabled"
+                )
+            with open(kokkos_modfile_file, "w") as f:
+                f.write(kokkos_modfile)
+        if adios2_modfile != "":
+            adios2_modfile_file = os.path.join(
+                settings.install_prefix,
+                "modules",
+                "adios2",
+                settings.adios2_mpi,
+                settings.adios2_version,
+            )
+            os.makedirs(os.path.dirname(adios2_modfile_file), exist_ok=True)
+            if os.path.exists(adios2_modfile_file) and not settings.overwrite:
+                raise FileExistsError(
+                    f"modulefile {adios2_modfile_file} already exists and overwrite is disabled"
+                )
+            with open(adios2_modfile_file, "w") as f:
+                f.write(adios2_modfile)
+
+    os.chmod(os.path.join(settings.install_prefix, "install.sh"), 0o755)
+    MESSAGE = f"- installation script written to {os.path.join(settings.install_prefix, 'install.sh')}!\n"
+    MESSAGE += "  please read and verify it before running.\n\n"
+    if settings.write_modulefiles:
+        MESSAGE += f"- module files have been written to {os.path.join(settings.install_prefix, 'modules')} directory.\n"
+        MESSAGE += f"  add them to your .rc script as `module use --append {os.path.join(settings.install_prefix, 'modules')}`\n\n"
+
+    if settings.apps.get("nt2py", False):
+        MESSAGE += (
+            "- nt2py installed in a new virtual environment at "
+            f"{os.path.join(settings.install_prefix, '.venv')}.\n"
+        )
+        MESSAGE += "  activate it with `source {}/bin/activate`.\n\n".format(
+            os.path.join(settings.install_prefix, ".venv")
+        )
+
+    settings_json = os.path.join(settings.install_prefix, "settings.json")
+    with open(settings_json, "w") as f:
+        f.write(settings.to_json())
+    return
+
+
+@dataclass
+class MenuItem:
+    label: str
+    hint: str = ""
+    right: Optional[Callable[[], str]] = None
+    on_enter: Optional[Callable[[], None]] = None
+    on_space: Optional[Callable[[], None]] = None
+    disabled: Optional[Callable[[], bool]] = None
+
+
+class TuiExitInstall(Exception):
+    pass
+
+
+class App:
+    def __init__(self, stdscr):
+        self.stdscr = stdscr
+        self.s = Settings()
+        if os.path.exists(os.path.join(self.s.install_prefix, "settings.json")):
+            with open(os.path.join(self.s.install_prefix, "settings.json"), "r") as f:
+                data = json.load(f)
+            self.s.from_json(json.dumps(data))
+
+        self.state = "mainmenu"
+        self.stack: List[Tuple[str, int]] = []
+        self.selected = 0
+        self.scroll = 0
+        self.message = "use arrows or j/k"
+
+        self.mod_sel = 0
+        self.mod_scroll = 0
+
+        self._init_curses()
+
+    def _init_curses(self) -> None:
+        curses.curs_set(0)
+        self.stdscr.keypad(True)
+        curses.noecho()
+        curses.cbreak()
+
+        if curses.has_colors():
+            curses.start_color()
+            curses.use_default_colors()
+            curses.init_pair(PAIR_TITLE, COLOR_TITLE_FG, -1)
+            curses.init_pair(PAIR_TEXT, COLOR_TEXT_FG, -1)
+            curses.init_pair(PAIR_SELECTED, COLOR_SELECTED_FG, COLOR_SELECTED_BG)
+            curses.init_pair(PAIR_HINT, COLOR_HINT_FG, -1)
+            curses.init_pair(PAIR_OK, COLOR_OK_FG, -1)
+            curses.init_pair(PAIR_ERR, COLOR_ERR_FG, -1)
+            curses.init_pair(PAIR_KEY, COLOR_KEY_FG, -1)
+            curses.init_pair(PAIR_DIM, COLOR_DIM_FG, -1)
+
+    def cp(self, pair_id: int) -> int:
+        return curses.color_pair(pair_id) if curses.has_colors() else 0
+
+    # ----- formatting helpers -----
+
+    def checkbox(self, on: bool) -> str:
+        return "[x]" if on else "[ ]"
+
+    def pill(self, on: bool) -> str:
+        return "[on]" if on else "[off]"
+
+    def kokkos_right(self) -> str:
+        arch = self.s.kokkos_arch.strip() or "-"
+        return f"{self.s.kokkos_version} · {self.s.kokkos_backend} · {arch}"
+
+    def adios2_right(self) -> str:
+        return f"{self.s.adios2_version} · {self.s.adios2_mpi}"
+
+    # ----- nav stack -----
+
+    def push(self, st: str) -> None:
+        self.stack.append((self.state, self.selected))
+        self.state = st
+        self.selected = 0
+        self.scroll = 0
+        self.message = ""
+
+    def pop(self) -> None:
+        if self.stack:
+            self.state, self.selected = self.stack.pop()
+        else:
+            self.state, self.selected = "mainmenu", 0
+        self.scroll = 0
+        self.message = ""
+
+    # ----- drawing -----
+
+    def add(self, y: int, x: int, s: str, attr: int = 0) -> None:
+        try:
+            self.stdscr.addstr(y, x, s, attr)
+        except curses.error:
+            pass
+
+    def hline(self, y: int) -> None:
+        _, w = self.stdscr.getmaxyx()
+        try:
+            self.stdscr.hline(y, 0, curses.ACS_HLINE, max(0, w - 1))
+        except curses.error:
+            pass
+
+    def draw_keybar(self, y: int, x: int, pairs: List[Tuple[str, str]]) -> None:
+        cur_x = x
+        for key, action in pairs:
+            self.add(y, cur_x, key, self.cp(PAIR_KEY) | curses.A_BOLD)
+            cur_x += len(key)
+            self.add(y, cur_x, " ", self.cp(PAIR_DIM))
+            cur_x += 1
+            self.add(y, cur_x, action, self.cp(PAIR_HINT))
+            cur_x += len(action)
+            self.add(y, cur_x, "   ", self.cp(PAIR_DIM))
+            cur_x += 3
+
+    def breadcrumb(self) -> str:
+        if self.state == "mainmenu":
+            return "mainmenu"
+        if self.state == "custom":
+            return "mainmenu › custom install"
+        if self.state == "dependencies":
+            return "mainmenu › custom install › dependencies"
+        if self.state == "versions":
+            return "mainmenu › custom install › versions"
+        if self.state == "options":
+            return "mainmenu › custom install › options"
+        if self.state == "cluster":
+            return "mainmenu › cluster-specific"
+        if self.state == "preset_applied":
+            return f"mainmenu › cluster-specific › {self.s.cluster}"
+        return "mainmenu"
+
+    def draw_menu(self, title: str, prompt: str, items: List[MenuItem]) -> None:
+        self.stdscr.erase()
+        h, w = self.stdscr.getmaxyx()
+
+        self.add(0, 2, title, self.cp(PAIR_TITLE) | curses.A_BOLD)
+        bc = self.breadcrumb()
+        self.add(0, max(2, w - 2 - len(bc)), bc, self.cp(PAIR_DIM))
+
+        self.draw_keybar(
+            1,
+            2,
+            [
+                ("↑/↓/j/k", "move"),
+                ("enter", "select"),
+                ("space", "toggle/cycle"),
+                ("b", "back"),
+                ("q", "quit"),
+            ],
+        )
+        self.hline(2)
+
+        status1 = f"cluster: {self.s.cluster}    write modulefiles: {self.pill(self.s.write_modulefiles)}    module loads: {len(self.s.module_loads)}"
+        status2 = (
+            f"prefix: {self.s.install_prefix}    dependencies: {self.s.apps_summary()}"
+        )
+        self.add(3, 2, status1[: w - 4], self.cp(PAIR_TEXT))
+        self.add(4, 2, status2[: w - 4], self.cp(PAIR_TEXT))
+        self.hline(5)
+
+        self.add(6, 2, prompt[: w - 4], self.cp(PAIR_TEXT) | curses.A_BOLD)
+
+        list_y = 8
+        footer_h = 3
+        view_h = max(1, h - list_y - footer_h)
+        n = len(items)
+
+        if n == 0:
+            self.add(list_y, 2, "(empty)", self.cp(PAIR_HINT))
+        else:
+            self.selected = max(0, min(self.selected, n - 1))
+
+            if self.selected < self.scroll:
+                self.scroll = self.selected
+            if self.selected >= self.scroll + view_h:
+                self.scroll = self.selected - view_h + 1
+            self.scroll = max(0, min(self.scroll, max(0, n - view_h)))
+
+            shown = items[self.scroll : self.scroll + view_h]
+
+            for i, it in enumerate(shown):
+                idx = self.scroll + i
+                sel = idx == self.selected
+                dis = bool(it.disabled and it.disabled())
+
+                row_attr = (
+                    self.cp(PAIR_SELECTED) | curses.A_BOLD
+                    if sel
+                    else (self.cp(PAIR_DIM) if dis else self.cp(PAIR_TEXT))
+                )
+                self.add(list_y + i, 2, f"  {it.label}"[: w - 4], row_attr)
+
+                if it.right:
+                    rt = (it.right() or "").strip()
+                    if rt:
+                        rt = rt[: max(0, w - 6)]
+                        x = max(2, w - 2 - len(rt))
+                        rt_attr = (
+                            row_attr
+                            if sel
+                            else (self.cp(PAIR_HINT) if not dis else self.cp(PAIR_DIM))
+                        )
+                        self.add(list_y + i, x, rt, rt_attr)
+
+                if sel and it.hint:
+                    self.add(
+                        list_y + i,
+                        min(w - 4, 30),
+                        f"    {it.hint}"[: w - 4],
+                        self.cp(PAIR_HINT),
+                    )
+
+        self.hline(h - 3)
+        msg = self.message or ""
+        if msg:
+            is_err = msg.startswith("error")
+            attr = (self.cp(PAIR_ERR) if is_err else self.cp(PAIR_OK)) | curses.A_BOLD
+            self.add(h - 2, 2, msg[: w - 4], attr)
+        self.stdscr.refresh()
+
+    # ----- modals -----
+
+    def input_box(self, title: str, prompt: str, initial: str) -> Optional[str]:
+        h, w = self.stdscr.getmaxyx()
+        win_h, win_w = 9, min(86, max(46, w - 6))
+        top, left = max(0, (h - win_h) // 2), max(0, (w - win_w) // 2)
+
+        win = curses.newwin(win_h, win_w, top, left)
+        win.keypad(True)
+        win.border()
+
+        win.addstr(1, 2, title[: win_w - 4], self.cp(PAIR_TITLE) | curses.A_BOLD)
+        win.addstr(2, 2, prompt[: win_w - 4], self.cp(PAIR_TEXT))
+
+        buf = list(initial)
+        curses.curs_set(1)
+
+        while True:
+            win.addstr(4, 2, " " * (win_w - 4), self.cp(PAIR_TEXT))
+            text = "".join(buf)
+            if len(text) > win_w - 4:
+                text = text[-(win_w - 4) :]
+            win.addstr(4, 2, text, self.cp(PAIR_TEXT) | curses.A_BOLD)
+            win.addstr(6, 2, "enter=ok   esc=cancel", self.cp(PAIR_DIM))
+            win.refresh()
+
+            ch = win.getch()
+            if ch == 27:
+                curses.curs_set(0)
+                return None
+            if ch in (curses.KEY_ENTER, 10, 13):
+                curses.curs_set(0)
+                return "".join(buf).strip()
+            if ch in (curses.KEY_BACKSPACE, 127, 8):
+                if buf:
+                    buf.pop()
+            elif 32 <= ch <= 126:
+                buf.append(chr(ch))
+
+    def confirm_install(self) -> bool:
+        arch = self.s.kokkos_arch.strip() or "-"
+        lines = [
+            f"cluster: {self.s.cluster}",
+            f"overwrite existing files: {self.pill(self.s.overwrite)}",
+            f"write modulefiles: {self.pill(self.s.write_modulefiles)}",
+            f"module loads: {len(self.s.module_loads)}",
+            f"prefix: {self.s.install_prefix}",
+            f"dependencies: {self.s.apps_summary()}",
+            f"kokkos: {self.s.kokkos_version} · {self.s.kokkos_backend} · {arch}",
+            f"adios2: {self.s.adios2_version} · {self.s.adios2_mpi}",
+            "",
+            "confirm install?",
+        ]
+
+        h, w = self.stdscr.getmaxyx()
+        win_h, win_w = min(16, max(10, h - 6)), min(94, max(52, w - 6))
+        top, left = max(0, (h - win_h) // 2), max(0, (w - win_w) // 2)
+
+        win = curses.newwin(win_h, win_w, top, left)
+        win.keypad(True)
+        win.border()
+        win.addstr(1, 2, "confirm", self.cp(PAIR_TITLE) | curses.A_BOLD)
+
+        y = 3
+        for ln in lines[: win_h - 6]:
+            win.addstr(y, 2, ln[: win_w - 4], self.cp(PAIR_TEXT))
+            y += 1
+
+        win.addstr(win_h - 3, 2, "y=yes   n=no", self.cp(PAIR_DIM))
+        win.refresh()
+
+        while True:
+            ch = win.getch()
+            if ch in (ord("y"), ord("Y")):
+                return True
+            if ch in (ord("n"), ord("N"), 27):
+                return False
+
+    # ----- helpers -----
+
+    def cycle(self, current: str, options: List[str]) -> str:
+        if current not in options:
+            return options[0]
+        i = options.index(current)
+        return options[(i + 1) % len(options)]
+
+    # ----- module editor -----
+
+    def module_editor(self) -> None:
+        while True:
+            self.stdscr.erase()
+            h, w = self.stdscr.getmaxyx()
+
+            self.add(0, 2, "module lines", self.cp(PAIR_TITLE) | curses.A_BOLD)
+            self.draw_keybar(
+                1,
+                2,
+                [
+                    ("↑/↓/j/k", "move"),
+                    ("enter", "edit"),
+                    ("a", "add"),
+                    ("d", "delete"),
+                    ("u/m", "reorder"),
+                    ("b", "back"),
+                ],
+            )
+            self.hline(2)
+
+            self.add(3, 2, f"lines: {len(self.s.module_loads)}", self.cp(PAIR_TEXT))
+            self.hline(4)
+
+            lines = self.s.module_loads
+            n = len(lines)
+            list_y = 6
+            view_h = max(1, h - list_y - 3)
+
+            if n == 0:
+                self.add(list_y, 2, "(empty) press a to add", self.cp(PAIR_HINT))
+            else:
+                self.mod_sel = max(0, min(self.mod_sel, n - 1))
+                if self.mod_sel < self.mod_scroll:
+                    self.mod_scroll = self.mod_sel
+                if self.mod_sel >= self.mod_scroll + view_h:
+                    self.mod_scroll = self.mod_sel - view_h + 1
+                self.mod_scroll = max(0, min(self.mod_scroll, max(0, n - view_h)))
+
+                shown = lines[self.mod_scroll : self.mod_scroll + view_h]
+                for i, ln in enumerate(shown):
+                    idx = self.mod_scroll + i
+                    sel = idx == self.mod_sel
+                    attr = (
+                        self.cp(PAIR_SELECTED) | curses.A_BOLD
+                        if sel
+                        else self.cp(PAIR_TEXT)
+                    )
+                    self.add(list_y + i, 2, f"  {ln}"[: w - 4], attr)
+
+            self.hline(h - 3)
+            self.add(
+                h - 2,
+                2,
+                "tip: example: cuda/12.9"[: w - 4],
+                self.cp(PAIR_HINT),
+            )
+            self.stdscr.refresh()
+
+            ch = self.stdscr.getch()
+            if ch in (ord("q"), ord("Q"), ord("b"), 8, 127):
+                return
+
+            n = len(self.s.module_loads)
+            self.mod_sel = 0 if n == 0 else max(0, min(self.mod_sel, n - 1))
+
+            if ch in (curses.KEY_UP, ord("k"), ord("K")) and n:
+                self.mod_sel = (self.mod_sel - 1) % n
+                continue
+            if ch in (curses.KEY_DOWN, ord("j"), ord("J")) and n:
+                self.mod_sel = (self.mod_sel + 1) % n
+                continue
+
+            if ch in (ord("a"), ord("A")):
+                val = self.input_box("add module line", "example: cuda/12.9", "")
+                if val:
+                    self.s.module_loads.append(val)
+                    self.mod_sel = len(self.s.module_loads) - 1
+                continue
+
+            if ch in (ord("d"), ord("D")):
+                if n == 0:
+                    continue
+                val = self.input_box("delete line", "type 'delete' to confirm:", "")
+                if val == "delete":
+                    del self.s.module_loads[self.mod_sel]
+                    self.mod_sel = max(
+                        0, min(self.mod_sel, len(self.s.module_loads) - 1)
+                    )
+                continue
+
+            if ch in (ord("u"), ord("U")):
+                if n >= 2 and self.mod_sel > 0:
+                    i = self.mod_sel
+                    self.s.module_loads[i - 1], self.s.module_loads[i] = (
+                        self.s.module_loads[i],
+                        self.s.module_loads[i - 1],
+                    )
+                    self.mod_sel -= 1
+                continue
+
+            if ch in (ord("m"), ord("M")):
+                if n >= 2 and self.mod_sel < n - 1:
+                    i = self.mod_sel
+                    self.s.module_loads[i + 1], self.s.module_loads[i] = (
+                        self.s.module_loads[i],
+                        self.s.module_loads[i + 1],
+                    )
+                    self.mod_sel += 1
+                continue
+
+            if ch in (curses.KEY_ENTER, 10, 13):
+                if n == 0:
+                    continue
+                cur = self.s.module_loads[self.mod_sel]
+                val = self.input_box("edit module line", "edit the selected line:", cur)
+                if val is not None and val.strip():
+                    self.s.module_loads[self.mod_sel] = val.strip()
+                continue
+
+    # ----- menus -----
+
+    def versions_menu(self) -> Tuple[str, str, List[MenuItem]]:
+        def edit_kokkos():
+            val = self.input_box(
+                "kokkos version", "enter version/tag:", self.s.kokkos_version
+            )
+            if val:
+                self.s.kokkos_version = val.strip()
+
+        def edit_adios2():
+            val = self.input_box(
+                "adios2 version", "enter version/tag:", self.s.adios2_version
+            )
+            if val:
+                self.s.adios2_version = val.strip()
+
+        return (
+            "versions",
+            "set versions:",
+            [
+                MenuItem(
+                    "kokkos version",
+                    "enter to edit",
+                    right=lambda: self.s.kokkos_version,
+                    on_enter=edit_kokkos,
+                ),
+                MenuItem(
+                    "adios2 version",
+                    "enter to edit",
+                    right=lambda: self.s.adios2_version,
+                    on_enter=edit_adios2,
+                ),
+                MenuItem("back", "return", on_enter=self.pop),
+            ],
+        )
+
+    def options_menu(self) -> Tuple[str, str, List[MenuItem]]:
+        def cycle_kokkos():
+            self.s.kokkos_backend = self.cycle(self.s.kokkos_backend, KOKKOS_BACKENDS)
+
+        def edit_kokkos_arch():
+            val = self.input_box(
+                "kokkos arch", "enter arch text (free-form):", self.s.kokkos_arch
+            )
+            if val is not None:
+                self.s.kokkos_arch = val.strip()
+
+        def cycle_adios2():
+            self.s.adios2_mpi = self.cycle(self.s.adios2_mpi, ADIOS2_MPI_MODES)
+
+        return (
+            "options",
+            "set build options:",
+            [
+                MenuItem(
+                    "kokkos backend",
+                    "space cycles: cpu/cuda/hip/sycl",
+                    right=lambda: self.s.kokkos_backend,
+                    on_enter=cycle_kokkos,
+                    on_space=cycle_kokkos,
+                    disabled=lambda: not self.s.apps.get("Kokkos", False),
+                ),
+                MenuItem(
+                    "kokkos arch",
+                    "enter to edit (optional)",
+                    right=lambda: (self.s.kokkos_arch.strip() or "-"),
+                    on_enter=edit_kokkos_arch,
+                    disabled=lambda: not self.s.apps.get("Kokkos", False),
+                ),
+                MenuItem(
+                    "adios2 mpi",
+                    "space cycles: non-mpi/mpi",
+                    right=lambda: self.s.adios2_mpi,
+                    on_enter=cycle_adios2,
+                    on_space=cycle_adios2,
+                    disabled=lambda: not self.s.apps.get("adios2", False),
+                ),
+                MenuItem("back", "return", on_enter=self.pop),
+            ],
+        )
+
+    def menu_main(self) -> Tuple[str, str, List[MenuItem]]:
+        return (
+            "entity deps",
+            "main menu:",
+            [
+                MenuItem(
+                    "custom install",
+                    "edit settings then install",
+                    on_enter=lambda: self.push("custom"),
+                ),
+                MenuItem(
+                    "cluster-specific",
+                    "apply a cluster-specific preset (editable)",
+                    on_enter=lambda: self.push("cluster"),
+                ),
+                MenuItem("exit", "", on_enter=lambda: setattr(self, "state", "exit")),
+            ],
+        )
+
+    def menu_custom(self) -> Tuple[str, str, List[MenuItem]]:
+        def toggle_write_modulefiles():
+            self.s.write_modulefiles = not self.s.write_modulefiles
+
+        def toggle_overwrite():
+            self.s.overwrite = not self.s.overwrite
+
+        def edit_prefix():
+            val = self.input_box(
+                "install location", "enter install prefix:", self.s.install_prefix
+            )
+            if val:
+                self.s.install_prefix = os.path.expanduser(val.strip())
+
+        def go_apps():
+            self.push("dependencies")
+
+        def go_versions():
+            self.push("versions")
+
+        def go_options():
+            self.push("options")
+
+        def do_install():
+            if not self.confirm_install():
+                self.message = "cancelled."
+                return
+            on_install_confirmed(self.s)
+            raise TuiExitInstall
+
+        return (
+            "custom install",
+            "settings:",
+            [
+                MenuItem(
+                    "overwrite existing files",
+                    "whether to overwrite existing files",
+                    right=lambda: "enabled" if self.s.overwrite else "disabled",
+                    on_enter=toggle_overwrite,
+                    on_space=toggle_overwrite,
+                ),
+                MenuItem(
+                    "write modulefiles",
+                    "whether to create module files",
+                    right=lambda: "enabled" if self.s.write_modulefiles else "disabled",
+                    on_enter=toggle_write_modulefiles,
+                    on_space=toggle_write_modulefiles,
+                ),
+                MenuItem(
+                    "module load lines",
+                    "add/remove modules to load",
+                    right=lambda: f"{len(self.s.module_loads)} entry(s)",
+                    on_enter=self.module_editor,
+                ),
+                MenuItem(
+                    "install location",
+                    "root location where modules and dependencies are installed",
+                    right=lambda: self.s.install_prefix,
+                    on_enter=edit_prefix,
+                ),
+                MenuItem(
+                    "dependencies to install",
+                    "select which dependencies to install",
+                    right=lambda: self.s.apps_summary(),
+                    on_enter=go_apps,
+                ),
+                MenuItem(
+                    "versions",
+                    "edit dependency versions",
+                    right=lambda: " · ".join(
+                        [
+                            a
+                            for (a, ae) in zip(
+                                [
+                                    f"kokkos {self.s.kokkos_version}",
+                                    f"adios2 {self.s.adios2_version}",
+                                ],
+                                [
+                                    self.s.apps.get(app, False)
+                                    for app in ["Kokkos", "adios2"]
+                                ],
+                            )
+                            if ae
+                        ]
+                    ),
+                    on_enter=go_versions,
+                ),
+                MenuItem(
+                    "options",
+                    "pick backends/architectures/mpi",
+                    right=lambda: " · ".join(
+                        [
+                            a
+                            for (a, ae) in zip(
+                                [
+                                    f"kokkos {self.s.kokkos_backend}/{self.s.kokkos_arch.strip() or '-'}",
+                                    f"adios2 {self.s.adios2_mpi}",
+                                ],
+                                [
+                                    self.s.apps.get(app, False)
+                                    for app in ["Kokkos", "adios2"]
+                                ],
+                            )
+                            if ae
+                        ]
+                    ),
+                    on_enter=go_options,
+                ),
+                MenuItem("install", "", on_enter=do_install),
+                MenuItem("back", "", on_enter=self.pop),
+            ],
+        )
+
+    def menu_apps(self) -> Tuple[str, str, List[MenuItem]]:
+        def toggle(k: str):
+            self.s.apps[k] = not self.s.apps.get(k, False)
+
+        return (
+            "dependencies",
+            "select the dependencies:",
+            [
+                MenuItem(
+                    f"{self.checkbox(self.s.apps.get('Kokkos', False))} kokkos",
+                    "",
+                    on_enter=lambda: toggle("Kokkos"),
+                    on_space=lambda: toggle("Kokkos"),
+                    right=self.kokkos_right,
+                ),
+                MenuItem(
+                    f"{self.checkbox(self.s.apps.get('adios2', False))} adios2",
+                    "",
+                    on_enter=lambda: toggle("adios2"),
+                    on_space=lambda: toggle("adios2"),
+                    right=self.adios2_right,
+                ),
+                MenuItem(
+                    f"{self.checkbox(self.s.apps.get('nt2py', False))} nt2py",
+                    "",
+                    on_enter=lambda: toggle("nt2py"),
+                    on_space=lambda: toggle("nt2py"),
+                ),
+                MenuItem("back", "", on_enter=self.pop),
+            ],
+        )
+
+    def menu_cluster(self) -> Tuple[str, str, List[MenuItem]]:
+        def choose(name: str):
+            apply_preset(self.s, name)
+            self.push("custom")
+
+        return (
+            "cluster-specific",
+            "pick a preset:",
+            [
+                MenuItem("rusty", "apply preset", on_enter=lambda: choose("rusty")),
+                MenuItem("stellar", "apply preset", on_enter=lambda: choose("stellar")),
+                MenuItem(
+                    "perlmutter", "apply preset", on_enter=lambda: choose("perlmutter")
+                ),
+                MenuItem(
+                    "frontier", "apply preset", on_enter=lambda: choose("frontier")
+                ),
+                MenuItem("aurora", "apply preset", on_enter=lambda: choose("aurora")),
+                MenuItem("back", "", on_enter=self.pop),
+            ],
+        )
+
+    def get_menu(self) -> Tuple[str, str, List[MenuItem]]:
+        if self.state == "mainmenu":
+            return self.menu_main()
+        if self.state == "custom":
+            return self.menu_custom()
+        if self.state == "dependencies":
+            return self.menu_apps()
+        if self.state == "versions":
+            return self.versions_menu()
+        if self.state == "options":
+            return self.options_menu()
+        if self.state == "cluster":
+            return self.menu_cluster()
+        self.state = "mainmenu"
+        return self.menu_main()
+
+    # ----- navigation -----
+
+    def is_disabled(self, it: MenuItem) -> bool:
+        return bool(it.disabled and it.disabled())
+
+    def move_sel(self, items: List[MenuItem], delta: int) -> None:
+        if not items:
+            return
+        n = len(items)
+        start = self.selected
+        for _ in range(n):
+            self.selected = (self.selected + delta) % n
+            if not self.is_disabled(items[self.selected]):
+                return
+        self.selected = start
+
+    def activate(self, items: List[MenuItem], enter: bool) -> None:
+        if not items:
+            return
+        it = items[self.selected]
+        if self.is_disabled(it):
+            self.message = "error: option disabled."
+            return
+        fn = it.on_enter if enter else it.on_space
+        if fn:
+            fn()
+
+    # ----- loop -----
+
+    def run(self) -> None:
+        while True:
+            if self.state == "exit":
+                return
+
+            title, prompt, items = self.get_menu()
+            self.draw_menu(title, prompt, items)
+
+            ch = self.stdscr.getch()
+
+            if ch in (ord("q"), ord("Q")):
+                self.state = "exit"
+                continue
+
+            if ch in (ord("b"), 8, 127):
+                self.pop()
+                continue
+
+            if ch in (curses.KEY_UP, ord("k"), ord("K")):
+                self.move_sel(items, -1)
+                continue
+
+            if ch in (curses.KEY_DOWN, ord("j"), ord("J")):
+                self.move_sel(items, +1)
+                continue
+
+            if ch in (curses.KEY_ENTER, 10, 13):
+                self.activate(items, enter=True)
+                continue
+
+            if ch == ord(" "):
+                self.activate(items, enter=False)
+                continue
+
+
+def _wrapper_capture(stdscr) -> None:
+    app = App(stdscr)
+    try:
+        app.run()
+    except TuiExitInstall:
+        on_install_confirmed(app.s)
+        raise
+
+
+if __name__ == "__main__":
+    try:
+        curses.wrapper(_wrapper_capture)
+        raise SystemExit(0)
+    except TuiExitInstall:
+        print(MESSAGE)
+        raise SystemExit(0)
+    except KeyboardInterrupt:
+        raise SystemExit(130)
diff --git a/dev/nix/adios2.nix b/dev/nix/adios2.nix
index a3890b788..810c228dc 100644
--- a/dev/nix/adios2.nix
+++ b/dev/nix/adios2.nix
@@ -6,9 +6,9 @@
 
 let
   name = "adios2";
-  version = "2.10.2";
+  version = "2.11.0";
   cmakeFlags = {
-    CMAKE_CXX_STANDARD = "17";
+    CMAKE_CXX_STANDARD = "20";
     CMAKE_CXX_EXTENSIONS = "OFF";
     CMAKE_POSITION_INDEPENDENT_CODE = "TRUE";
     BUILD_SHARED_LIBS = "ON";
@@ -30,7 +30,7 @@ stdenv.mkDerivation {
   src = pkgs.fetchgit {
     url = "https://github.com/ornladios/ADIOS2/";
     rev = "v${version}";
-    sha256 = "sha256-NVyw7xoPutXeUS87jjVv1YxJnwNGZAT4QfkBLzvQbwg=";
+    sha256 = "sha256-yHPI///17poiCEb7Luu5qfqxTWm9Nh+o9r57mZT26U0=";
   };
 
   nativeBuildInputs = with pkgs; [
diff --git a/dev/nix/kokkos.nix b/dev/nix/kokkos.nix
index 7d86e665b..f51d2c685 100644
--- a/dev/nix/kokkos.nix
+++ b/dev/nix/kokkos.nix
@@ -7,25 +7,26 @@
 
 let
   name = "kokkos";
-  pversion = "4.7.01";
+  pversion = "5.0.1";
   compilerPkgs = {
     "HIP" = with pkgs.rocmPackages; [
-      llvm.rocm-merged-llvm
+      clang
       rocm-core
       clr
       rocthrust
       rocprim
       rocminfo
       rocm-smi
+      pkgs.clang-tools
     ];
     "CUDA" = with pkgs.cudaPackages; [
-      llvmPackages_18.clang-tools
+      pkgs.clang-tools
       cudatoolkit
       cuda_cudart
       pkgs.gcc13
     ];
     "NONE" = [
-      pkgs.llvmPackages_18.clang-tools
+      pkgs.clang-tools
       pkgs.gcc13
     ];
   };
@@ -39,8 +40,8 @@ let
     "HIP" = [
       "-D Kokkos_ENABLE_HIP=ON"
       "-D Kokkos_ARCH_${getArch { }}=ON"
-      "-D AMDGPU_TARGETS=${builtins.replaceStrings [ "amd_" ] [ "" ] (pkgs.lib.toLower (getArch { }))}"
-      "-D CMAKE_CXX_COMPILER=hipcc"
+      "-D GPU_TARGETS=${builtins.replaceStrings [ "amd_" ] [ "" ] (pkgs.lib.toLower (getArch { }))}"
+      "-D CMAKE_CXX_COMPILER=clang++"
     ];
     "CUDA" = [
       "-D Kokkos_ENABLE_CUDA=ON"
@@ -56,7 +57,7 @@ pkgs.stdenv.mkDerivation rec {
   src = pkgs.fetchgit {
     url = "https://github.com/kokkos/kokkos/";
     rev = "${pversion}";
-    sha256 = "sha256-MgphOsKE8umgYxVQZzex+elgvDDC09JaMCoU5YXaLco=";
+    sha256 = "sha256-ChpwGBwE7sNovjdAM/iCeOqqwGufKxAh5vQ3qK6aFBU=";
   };
 
   nativeBuildInputs = with pkgs; [
@@ -78,7 +79,7 @@ pkgs.stdenv.mkDerivation rec {
 
   configurePhase = ''
     cmake -B build -D CMAKE_BUILD_TYPE=Release \
-      -D CMAKE_CXX_STANDARD=17 \
+      -D CMAKE_CXX_STANDARD=20 \
       -D CMAKE_CXX_EXTENSIONS=OFF \
       -D CMAKE_POSITION_INDEPENDENT_CODE=TRUE \
       ${pkgs.lib.concatStringsSep " " cmakeExtraFlags.${gpu}} \
diff --git a/dev/nix/shell.nix b/dev/nix/shell.nix
index 0d4cc9119..c1a9dd165 100644
--- a/dev/nix/shell.nix
+++ b/dev/nix/shell.nix
@@ -29,8 +29,8 @@ let
         CC = "gcc";
       };
       HIP = {
-        CXX = "hipcc";
-        CC = "hipcc";
+        CXX = "clang++";
+        CC = "clang";
       };
       CUDA = { };
     };
@@ -45,8 +45,7 @@ pkgs.mkShell {
     adios2Pkg
     kokkosPkg
 
-    python312
-    python312Packages.jupyter
+    python314
 
     cmake-format
     cmake-lint
diff --git a/extern/Kokkos b/extern/Kokkos
index 1b1383c60..37f70304d 160000
--- a/extern/Kokkos
+++ b/extern/Kokkos
@@ -1 +1 @@
-Subproject commit 1b1383c6001f3bfe9fe309ca923c2d786600cc79
+Subproject commit 37f70304dc3676691af88d3ac3ba50cddbfa337f
diff --git a/extern/adios2 b/extern/adios2
index a19dad6ce..1ef0b5797 160000
--- a/extern/adios2
+++ b/extern/adios2
@@ -1 +1 @@
-Subproject commit a19dad6cecb00319825f20fd9f455ebbab903d34
+Subproject commit 1ef0b5797aeb8a1cc1bb36ec4089eaec19a2eea0
diff --git a/extern/plog b/extern/plog
deleted file mode 160000
index e21baecd4..000000000
--- a/extern/plog
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e21baecd4753f14da64ede979c5a19302618b752
diff --git a/include/plog/Appenders/AndroidAppender.h b/include/plog/Appenders/AndroidAppender.h
new file mode 100644
index 000000000..722488ab2
--- /dev/null
+++ b/include/plog/Appenders/AndroidAppender.h
@@ -0,0 +1,47 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <android/log.h>
+
+namespace plog
+{
+    template<class Formatter>
+    class PLOG_LINKAGE_HIDDEN AndroidAppender : public IAppender
+    {
+    public:
+        AndroidAppender(const char* tag) : m_tag(tag)
+        {
+        }
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            std::string str = Formatter::format(record);
+
+            __android_log_print(toPriority(record.getSeverity()), m_tag, "%s", str.c_str());
+        }
+
+    private:
+        static android_LogPriority toPriority(Severity severity)
+        {
+            switch (severity)
+            {
+            case fatal:
+                return ANDROID_LOG_FATAL;
+            case error:
+                return ANDROID_LOG_ERROR;
+            case warning:
+                return ANDROID_LOG_WARN;
+            case info:
+                return ANDROID_LOG_INFO;
+            case debug:
+                return ANDROID_LOG_DEBUG;
+            case verbose:
+                return ANDROID_LOG_VERBOSE;
+            default:
+                return ANDROID_LOG_UNKNOWN;
+            }
+        }
+
+    private:
+        const char* const m_tag;
+    };
+}
diff --git a/include/plog/Appenders/ArduinoAppender.h b/include/plog/Appenders/ArduinoAppender.h
new file mode 100644
index 000000000..276af323f
--- /dev/null
+++ b/include/plog/Appenders/ArduinoAppender.h
@@ -0,0 +1,23 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <Arduino.h>
+
+namespace plog
+{
+    template<class Formatter>
+    class PLOG_LINKAGE_HIDDEN ArduinoAppender : public IAppender
+    {
+    public:
+        ArduinoAppender(Stream &stream) : m_stream(stream)
+        {
+        }
+
+        virtual void write(const Record &record) PLOG_OVERRIDE
+        {
+            m_stream.print(Formatter::format(record).c_str());
+        }
+
+    private:
+        Stream &m_stream;
+    };
+}
diff --git a/include/plog/Appenders/ColorConsoleAppender.h b/include/plog/Appenders/ColorConsoleAppender.h
new file mode 100644
index 000000000..24bbc7d90
--- /dev/null
+++ b/include/plog/Appenders/ColorConsoleAppender.h
@@ -0,0 +1,108 @@
+#pragma once
+#include <plog/Appenders/ConsoleAppender.h>
+#include <plog/WinApi.h>
+
+namespace plog
+{
+    template<class Formatter>
+    class PLOG_LINKAGE_HIDDEN ColorConsoleAppender : public ConsoleAppender<Formatter>
+    {
+    public:
+#ifdef _WIN32
+#   ifdef _MSC_VER
+#       pragma warning(suppress: 26812) //  Prefer 'enum class' over 'enum'
+#   endif
+        ColorConsoleAppender(OutputStream outStream = streamStdOut)
+            : ConsoleAppender<Formatter>(outStream)
+            , m_originalAttr()
+        {
+            if (this->m_isatty)
+            {
+                CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+                GetConsoleScreenBufferInfo(this->m_outputHandle, &csbiInfo);
+
+                m_originalAttr = csbiInfo.wAttributes;
+            }
+        }
+#else
+        ColorConsoleAppender(OutputStream outStream = streamStdOut)
+            : ConsoleAppender<Formatter>(outStream)
+        {}
+#endif
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            util::nstring str = Formatter::format(record);
+            util::MutexLock lock(this->m_mutex);
+
+            setColor(record.getSeverity());
+            this->writestr(str);
+            resetColor();
+        }
+
+    protected:
+        void setColor(Severity severity)
+        {
+            if (this->m_isatty)
+            {
+                switch (severity)
+                {
+#ifdef _WIN32
+                case fatal:
+                    SetConsoleTextAttribute(this->m_outputHandle, foreground::kRed | foreground::kGreen | foreground::kBlue | foreground::kIntensity | background::kRed); // white on red background
+                    break;
+
+                case error:
+                    SetConsoleTextAttribute(this->m_outputHandle, static_cast<WORD>(foreground::kRed | foreground::kIntensity | (m_originalAttr & 0xf0))); // red
+                    break;
+
+                case warning:
+                    SetConsoleTextAttribute(this->m_outputHandle, static_cast<WORD>(foreground::kRed | foreground::kGreen | foreground::kIntensity | (m_originalAttr & 0xf0))); // yellow
+                    break;
+
+                case debug:
+                case verbose:
+                    SetConsoleTextAttribute(this->m_outputHandle, static_cast<WORD>(foreground::kGreen | foreground::kBlue | foreground::kIntensity | (m_originalAttr & 0xf0))); // cyan
+                    break;
+#else
+                case fatal:
+                    this->m_outputStream << "\x1B[97m\x1B[41m"; // white on red background
+                    break;
+
+                case error:
+                    this->m_outputStream << "\x1B[91m"; // red
+                    break;
+
+                case warning:
+                    this->m_outputStream << "\x1B[93m"; // yellow
+                    break;
+
+                case debug:
+                case verbose:
+                    this->m_outputStream << "\x1B[96m"; // cyan
+                    break;
+#endif
+                default:
+                    break;
+                }
+            }
+        }
+
+        void resetColor()
+        {
+            if (this->m_isatty)
+            {
+#ifdef _WIN32
+                SetConsoleTextAttribute(this->m_outputHandle, m_originalAttr);
+#else
+                this->m_outputStream << "\x1B[0m\x1B[0K";
+#endif
+            }
+        }
+
+    private:
+#ifdef _WIN32
+        WORD   m_originalAttr;
+#endif
+    };
+}
diff --git a/include/plog/Appenders/ConsoleAppender.h b/include/plog/Appenders/ConsoleAppender.h
new file mode 100644
index 000000000..a8925a049
--- /dev/null
+++ b/include/plog/Appenders/ConsoleAppender.h
@@ -0,0 +1,83 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <plog/Util.h>
+#include <plog/WinApi.h>
+#include <iostream>
+
+namespace plog
+{
+    enum OutputStream
+    {
+        streamStdOut,
+        streamStdErr
+    };
+
+    template<class Formatter>
+    class PLOG_LINKAGE_HIDDEN ConsoleAppender : public IAppender
+    {
+    public:
+#ifdef _WIN32
+#   ifdef _MSC_VER
+#       pragma warning(suppress: 26812) //  Prefer 'enum class' over 'enum'
+#   endif
+        ConsoleAppender(OutputStream outStream = streamStdOut)
+            : m_isatty(!!_isatty(_fileno(outStream == streamStdOut ? stdout : stderr)))
+            , m_outputStream(outStream == streamStdOut ? std::cout : std::cerr)
+            , m_outputHandle()
+        {
+            if (m_isatty)
+            {
+                m_outputHandle = GetStdHandle(outStream == streamStdOut ? stdHandle::kOutput : stdHandle::kErrorOutput);
+            }
+        }
+#else
+        ConsoleAppender(OutputStream outStream = streamStdOut)
+            : m_isatty(!!isatty(fileno(outStream == streamStdOut ? stdout : stderr)))
+            , m_outputStream(outStream == streamStdOut ? std::cout : std::cerr)
+        {}
+#endif
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            util::nstring str = Formatter::format(record);
+            util::MutexLock lock(m_mutex);
+
+            writestr(str);
+        }
+
+    protected:
+        void writestr(const util::nstring& str)
+        {
+#ifdef _WIN32
+            if (m_isatty)
+            {
+                const std::wstring& wstr = util::toWide(str);
+                WriteConsoleW(m_outputHandle, wstr.c_str(), static_cast<DWORD>(wstr.size()), NULL, NULL);
+            }
+            else
+            {
+#   if PLOG_CHAR_IS_UTF8
+                m_outputStream << str << std::flush;
+#   else
+                m_outputStream << util::toNarrow(str, codePage::kActive) << std::flush;
+#   endif
+            }
+#else
+            m_outputStream << str << std::flush;
+#endif
+        }
+
+    private:
+#ifdef __BORLANDC__
+        static int _isatty(int fd) { return ::isatty(fd); }
+#endif
+
+    protected:
+        util::Mutex m_mutex;
+        const bool  m_isatty;
+        std::ostream& m_outputStream;
+#ifdef _WIN32
+        HANDLE      m_outputHandle;
+#endif
+    };
+}
diff --git a/include/plog/Appenders/DebugOutputAppender.h b/include/plog/Appenders/DebugOutputAppender.h
new file mode 100644
index 000000000..5d7c95ef2
--- /dev/null
+++ b/include/plog/Appenders/DebugOutputAppender.h
@@ -0,0 +1,16 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <plog/WinApi.h>
+
+namespace plog
+{
+    template<class Formatter>
+    class PLOG_LINKAGE_HIDDEN DebugOutputAppender : public IAppender
+    {
+    public:
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            OutputDebugStringW(util::toWide(Formatter::format(record)).c_str());
+        }
+    };
+}
diff --git a/include/plog/Appenders/DynamicAppender.h b/include/plog/Appenders/DynamicAppender.h
new file mode 100644
index 000000000..f078c08cc
--- /dev/null
+++ b/include/plog/Appenders/DynamicAppender.h
@@ -0,0 +1,42 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <set>
+
+namespace plog
+{
+    class PLOG_LINKAGE_HIDDEN DynamicAppender : public IAppender
+    {
+    public:
+        DynamicAppender& addAppender(IAppender* appender)
+        {
+            assert(appender != this);
+
+            util::MutexLock lock(m_mutex);
+            m_appenders.insert(appender);
+
+            return *this;
+        }
+
+        DynamicAppender& removeAppender(IAppender* appender)
+        {
+            util::MutexLock lock(m_mutex);
+            m_appenders.erase(appender);
+
+            return *this;
+        }
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            util::MutexLock lock(m_mutex);
+
+            for (std::set<IAppender*>::iterator it = m_appenders.begin(); it != m_appenders.end(); ++it)
+            {
+                (*it)->write(record);
+            }
+        }
+
+    private:
+        mutable util::Mutex     m_mutex;
+        std::set<IAppender*>    m_appenders;
+    };
+}
diff --git a/include/plog/Appenders/EventLogAppender.h b/include/plog/Appenders/EventLogAppender.h
new file mode 100644
index 000000000..3b7065be1
--- /dev/null
+++ b/include/plog/Appenders/EventLogAppender.h
@@ -0,0 +1,117 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <plog/WinApi.h>
+
+namespace plog
+{
+    template <class Formatter>
+    class PLOG_LINKAGE_HIDDEN EventLogAppender : public IAppender
+    {
+    public:
+        EventLogAppender(const util::nchar* sourceName) : m_eventSource(RegisterEventSourceW(NULL, util::toWide(sourceName).c_str()))
+        {
+        }
+
+        ~EventLogAppender()
+        {
+            DeregisterEventSource(m_eventSource);
+        }
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            util::nstring str = Formatter::format(record);
+
+            write(record.getSeverity(), util::toWide(str).c_str());
+        }
+
+    private:
+        void write(Severity severity, const wchar_t* str)
+        {
+            const wchar_t* logMessagePtr[] = { str };
+
+            ReportEventW(m_eventSource, logSeverityToType(severity), static_cast<WORD>(severity), 0, NULL, 1, 0, logMessagePtr, NULL);
+        }
+
+        static WORD logSeverityToType(plog::Severity severity)
+        {
+            switch (severity)
+            {
+            case plog::fatal:
+            case plog::error:
+                return eventLog::kErrorType;
+
+            case plog::warning:
+                return eventLog::kWarningType;
+
+            case plog::info:
+            case plog::debug:
+            case plog::verbose:
+            default:
+                return eventLog::kInformationType;
+            }
+        }
+
+    private:
+        HANDLE m_eventSource;
+    };
+
+    class EventLogAppenderRegistry
+    {
+    public:
+        static bool add(const util::nchar* sourceName, const util::nchar* logName = PLOG_NSTR("Application"))
+        {
+            std::wstring logKeyName;
+            std::wstring sourceKeyName;
+            getKeyNames(sourceName, logName, sourceKeyName, logKeyName);
+
+            HKEY sourceKey;
+            if (0 != RegCreateKeyExW(hkey::kLocalMachine, sourceKeyName.c_str(), 0, NULL, 0, regSam::kSetValue, NULL, &sourceKey, NULL))
+            {
+                return false;
+            }
+
+            const DWORD kTypesSupported = eventLog::kErrorType | eventLog::kWarningType | eventLog::kInformationType;
+            RegSetValueExW(sourceKey, L"TypesSupported", 0, regType::kDword, reinterpret_cast<const BYTE*>(&kTypesSupported), sizeof(kTypesSupported));
+
+            const wchar_t kEventMessageFile[] = L"%windir%\\Microsoft.NET\\Framework\\v4.0.30319\\EventLogMessages.dll;%windir%\\Microsoft.NET\\Framework\\v2.0.50727\\EventLogMessages.dll";
+            RegSetValueExW(sourceKey, L"EventMessageFile", 0, regType::kExpandSz, reinterpret_cast<const BYTE*>(kEventMessageFile), sizeof(kEventMessageFile) - sizeof(*kEventMessageFile));
+
+            RegCloseKey(sourceKey);
+            return true;
+        }
+
+        static bool exists(const util::nchar* sourceName, const util::nchar* logName = PLOG_NSTR("Application"))
+        {
+            std::wstring logKeyName;
+            std::wstring sourceKeyName;
+            getKeyNames(sourceName, logName, sourceKeyName, logKeyName);
+
+            HKEY sourceKey;
+            if (0 != RegOpenKeyExW(hkey::kLocalMachine, sourceKeyName.c_str(), 0, regSam::kQueryValue, &sourceKey))
+            {
+                return false;
+            }
+
+            RegCloseKey(sourceKey);
+            return true;
+        }
+
+        static void remove(const util::nchar* sourceName, const util::nchar* logName = PLOG_NSTR("Application"))
+        {
+            std::wstring logKeyName;
+            std::wstring sourceKeyName;
+            getKeyNames(sourceName, logName, sourceKeyName, logKeyName);
+
+            RegDeleteKeyW(hkey::kLocalMachine, sourceKeyName.c_str());
+            RegDeleteKeyW(hkey::kLocalMachine, logKeyName.c_str());
+        }
+
+    private:
+        static void getKeyNames(const util::nchar* sourceName, const util::nchar* logName, std::wstring& sourceKeyName, std::wstring& logKeyName)
+        {
+            const std::wstring kPrefix = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\";
+            logKeyName = kPrefix + util::toWide(logName);
+            sourceKeyName = logKeyName + L"\\" + util::toWide(sourceName);
+        }
+    };
+}
diff --git a/include/plog/Appenders/IAppender.h b/include/plog/Appenders/IAppender.h
new file mode 100644
index 000000000..56b7827ae
--- /dev/null
+++ b/include/plog/Appenders/IAppender.h
@@ -0,0 +1,16 @@
+#pragma once
+#include <plog/Record.h>
+#include <plog/Util.h>
+
+namespace plog
+{
+    class PLOG_LINKAGE IAppender
+    {
+    public:
+        virtual ~IAppender()
+        {
+        }
+
+        virtual void write(const Record& record) = 0;
+    };
+}
diff --git a/include/plog/Appenders/RollingFileAppender.h b/include/plog/Appenders/RollingFileAppender.h
new file mode 100644
index 000000000..3b667287a
--- /dev/null
+++ b/include/plog/Appenders/RollingFileAppender.h
@@ -0,0 +1,148 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <plog/Converters/UTF8Converter.h>
+#include <plog/Converters/NativeEOLConverter.h>
+#include <plog/Util.h>
+#include <algorithm>
+
+namespace plog
+{
+    template<class Formatter, class Converter = NativeEOLConverter<UTF8Converter> >
+    class PLOG_LINKAGE_HIDDEN RollingFileAppender : public IAppender
+    {
+    public:
+        RollingFileAppender(const util::nchar* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+            : m_fileSize()
+            , m_maxFileSize()
+            , m_maxFiles(maxFiles)
+            , m_firstWrite(true)
+        {
+            setFileName(fileName);
+            setMaxFileSize(maxFileSize);
+        }
+
+#if defined(_WIN32) && !PLOG_CHAR_IS_UTF8
+        RollingFileAppender(const char* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+            : m_fileSize()
+            , m_maxFileSize()
+            , m_maxFiles(maxFiles)
+            , m_firstWrite(true)
+        {
+            setFileName(fileName);
+            setMaxFileSize(maxFileSize);
+        }
+#endif
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            util::MutexLock lock(m_mutex);
+
+            if (m_firstWrite)
+            {
+                openLogFile();
+                m_firstWrite = false;
+            }
+            else if (m_maxFiles > 0 && m_fileSize > m_maxFileSize && static_cast<size_t>(-1) != m_fileSize)
+            {
+                rollLogFiles();
+            }
+
+            size_t bytesWritten = m_file.write(Converter::convert(Formatter::format(record)));
+
+            if (static_cast<size_t>(-1) != bytesWritten)
+            {
+                m_fileSize += bytesWritten;
+            }
+        }
+
+        void setFileName(const util::nchar* fileName)
+        {
+            util::MutexLock lock(m_mutex);
+
+            util::splitFileName(fileName, m_fileNameNoExt, m_fileExt);
+
+            m_file.close();
+            m_firstWrite = true;
+        }
+
+#if defined(_WIN32) && !PLOG_CHAR_IS_UTF8
+        void setFileName(const char* fileName)
+        {
+            setFileName(util::toWide(fileName).c_str());
+        }
+#endif
+
+        void setMaxFiles(int maxFiles)
+        {
+            m_maxFiles = maxFiles;
+        }
+
+        void setMaxFileSize(size_t maxFileSize)
+        {
+            m_maxFileSize = (std::max)(maxFileSize, static_cast<size_t>(1000)); // set a lower limit for the maxFileSize
+        }
+
+        void rollLogFiles()
+        {
+            m_file.close();
+
+            util::nstring lastFileName = buildFileName(m_maxFiles - 1);
+            util::File::unlink(lastFileName);
+
+            for (int fileNumber = m_maxFiles - 2; fileNumber >= 0; --fileNumber)
+            {
+                util::nstring currentFileName = buildFileName(fileNumber);
+                util::nstring nextFileName = buildFileName(fileNumber + 1);
+
+                util::File::rename(currentFileName, nextFileName);
+            }
+
+            openLogFile();
+            m_firstWrite = false;
+        }
+
+    private:
+        void openLogFile()
+        {
+            m_fileSize = m_file.open(buildFileName());
+
+            if (0 == m_fileSize)
+            {
+                size_t bytesWritten = m_file.write(Converter::header(Formatter::header()));
+
+                if (static_cast<size_t>(-1) != bytesWritten)
+                {
+                    m_fileSize += bytesWritten;
+                }
+            }
+        }
+
+        util::nstring buildFileName(int fileNumber = 0)
+        {
+            util::nostringstream ss;
+            ss << m_fileNameNoExt;
+
+            if (fileNumber > 0)
+            {
+                ss << '.' << fileNumber;
+            }
+
+            if (!m_fileExt.empty())
+            {
+                ss << '.' << m_fileExt;
+            }
+
+            return ss.str();
+        }
+
+    private:
+        util::Mutex     m_mutex;
+        util::File      m_file;
+        size_t          m_fileSize;
+        size_t          m_maxFileSize;
+        int             m_maxFiles;
+        util::nstring   m_fileExt;
+        util::nstring   m_fileNameNoExt;
+        bool            m_firstWrite;
+    };
+}
diff --git a/include/plog/Converters/NativeEOLConverter.h b/include/plog/Converters/NativeEOLConverter.h
new file mode 100644
index 000000000..a395e4e89
--- /dev/null
+++ b/include/plog/Converters/NativeEOLConverter.h
@@ -0,0 +1,44 @@
+#pragma once
+#include <plog/Converters/UTF8Converter.h>
+#include <plog/Util.h>
+
+namespace plog
+{
+    template<class NextConverter = UTF8Converter>
+    class NativeEOLConverter : public NextConverter
+    {
+#ifdef _WIN32
+    public:
+        static std::string header(const util::nstring& str)
+        {
+            return NextConverter::header(fixLineEndings(str));
+        }
+
+        static std::string convert(const util::nstring& str)
+        {
+            return NextConverter::convert(fixLineEndings(str));
+        }
+
+    private:
+        static util::nstring fixLineEndings(const util::nstring& str)
+        {
+            util::nstring output;
+            output.reserve(str.length() * 2); // the worst case requires 2x chars
+
+            for (size_t i = 0; i < str.size(); ++i)
+            {
+                util::nchar ch = str[i];
+
+                if (ch == PLOG_NSTR('\n'))
+                {
+                    output.push_back(PLOG_NSTR('\r'));
+                }
+
+                output.push_back(ch);
+            }
+
+            return output;
+        }
+#endif
+    };
+}
diff --git a/include/plog/Converters/UTF8Converter.h b/include/plog/Converters/UTF8Converter.h
new file mode 100644
index 000000000..9de5a6303
--- /dev/null
+++ b/include/plog/Converters/UTF8Converter.h
@@ -0,0 +1,28 @@
+#pragma once
+#include <plog/Util.h>
+
+namespace plog
+{
+    class UTF8Converter
+    {
+    public:
+        static std::string header(const util::nstring& str)
+        {
+            const char kBOM[] = "\xEF\xBB\xBF";
+
+            return std::string(kBOM) + convert(str);
+        }
+
+#if PLOG_CHAR_IS_UTF8
+        static const std::string& convert(const util::nstring& str)
+        {
+            return str;
+        }
+#else
+        static std::string convert(const util::nstring& str)
+        {
+            return util::toNarrow(str, codePage::kUTF8);
+        }
+#endif
+    };
+}
diff --git a/include/plog/Formatters/CsvFormatter.h b/include/plog/Formatters/CsvFormatter.h
new file mode 100644
index 000000000..282c57f19
--- /dev/null
+++ b/include/plog/Formatters/CsvFormatter.h
@@ -0,0 +1,57 @@
+#pragma once
+#include <plog/Record.h>
+#include <plog/Util.h>
+#include <iomanip>
+
+namespace plog
+{
+    template<bool useUtcTime>
+    class CsvFormatterImpl
+    {
+    public:
+        static util::nstring header()
+        {
+            return PLOG_NSTR("Date;Time;Severity;TID;This;Function;Message\n");
+        }
+
+        static util::nstring format(const Record& record)
+        {
+            tm t;
+            useUtcTime ? util::gmtime_s(&t, &record.getTime().time) : util::localtime_s(&t, &record.getTime().time);
+
+            util::nostringstream ss;
+            ss << t.tm_year + 1900 << PLOG_NSTR("/") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_mon + 1 << PLOG_NSTR("/") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_mday << PLOG_NSTR(";");
+            ss << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_hour << PLOG_NSTR(":") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_min << PLOG_NSTR(":") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_sec << PLOG_NSTR(".") << std::setfill(PLOG_NSTR('0')) << std::setw(3) << static_cast<int> (record.getTime().millitm) << PLOG_NSTR(";");
+            ss << severityToString(record.getSeverity()) << PLOG_NSTR(";");
+            ss << record.getTid() << PLOG_NSTR(";");
+            ss << record.getObject() << PLOG_NSTR(";");
+            ss << record.getFunc() << PLOG_NSTR("@") << record.getLine() << PLOG_NSTR(";");
+
+            util::nstring message = record.getMessage();
+
+            if (message.size() > kMaxMessageSize)
+            {
+                message.resize(kMaxMessageSize);
+                message.append(PLOG_NSTR("..."));
+            }
+
+            util::nistringstream split(message);
+            util::nstring token;
+
+            while (!split.eof())
+            {
+                std::getline(split, token, PLOG_NSTR('"'));
+                ss << PLOG_NSTR("\"") << token << PLOG_NSTR("\"");
+            }
+
+            ss << PLOG_NSTR("\n");
+
+            return ss.str();
+        }
+
+        static const size_t kMaxMessageSize = 32000;
+    };
+
+    class CsvFormatter : public CsvFormatterImpl<false> {};
+    class CsvFormatterUtcTime : public CsvFormatterImpl<true> {};
+}
diff --git a/include/plog/Formatters/FuncMessageFormatter.h b/include/plog/Formatters/FuncMessageFormatter.h
new file mode 100644
index 000000000..aa57806b8
--- /dev/null
+++ b/include/plog/Formatters/FuncMessageFormatter.h
@@ -0,0 +1,23 @@
+#pragma once
+#include <plog/Record.h>
+#include <plog/Util.h>
+
+namespace plog
+{
+    class FuncMessageFormatter
+    {
+    public:
+        static util::nstring header()
+        {
+            return util::nstring();
+        }
+
+        static util::nstring format(const Record& record)
+        {
+            util::nostringstream ss;
+            ss << record.getFunc() << PLOG_NSTR("@") << record.getLine() << PLOG_NSTR(": ") << record.getMessage() << PLOG_NSTR("\n");
+
+            return ss.str();
+        }
+    };
+}
diff --git a/include/plog/Formatters/MessageOnlyFormatter.h b/include/plog/Formatters/MessageOnlyFormatter.h
new file mode 100644
index 000000000..b2db5a5a0
--- /dev/null
+++ b/include/plog/Formatters/MessageOnlyFormatter.h
@@ -0,0 +1,23 @@
+#pragma once
+#include <plog/Record.h>
+#include <plog/Util.h>
+
+namespace plog
+{
+    class MessageOnlyFormatter
+    {
+    public:
+        static util::nstring header()
+        {
+            return util::nstring();
+        }
+
+        static util::nstring format(const Record& record)
+        {
+            util::nostringstream ss;
+            ss << record.getMessage() << PLOG_NSTR("\n");
+
+            return ss.str();
+        }
+    };
+}
diff --git a/include/plog/Formatters/TxtFormatter.h b/include/plog/Formatters/TxtFormatter.h
new file mode 100644
index 000000000..48e2d50b8
--- /dev/null
+++ b/include/plog/Formatters/TxtFormatter.h
@@ -0,0 +1,36 @@
+#pragma once
+#include <plog/Record.h>
+#include <plog/Util.h>
+#include <iomanip>
+
+namespace plog
+{
+    template<bool useUtcTime>
+    class TxtFormatterImpl
+    {
+    public:
+        static util::nstring header()
+        {
+            return util::nstring();
+        }
+
+        static util::nstring format(const Record& record)
+        {
+            tm t;
+            useUtcTime ? util::gmtime_s(&t, &record.getTime().time) : util::localtime_s(&t, &record.getTime().time);
+
+            util::nostringstream ss;
+            ss << t.tm_year + 1900 << "-" << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_mon + 1 << PLOG_NSTR("-") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_mday << PLOG_NSTR(" ");
+            ss << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_hour << PLOG_NSTR(":") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_min << PLOG_NSTR(":") << std::setfill(PLOG_NSTR('0')) << std::setw(2) << t.tm_sec << PLOG_NSTR(".") << std::setfill(PLOG_NSTR('0')) << std::setw(3) << static_cast<int> (record.getTime().millitm) << PLOG_NSTR(" ");
+            ss << std::setfill(PLOG_NSTR(' ')) << std::setw(5) << std::left << severityToString(record.getSeverity()) << PLOG_NSTR(" ");
+            ss << PLOG_NSTR("[") << record.getTid() << PLOG_NSTR("] ");
+            ss << PLOG_NSTR("[") << record.getFunc() << PLOG_NSTR("@") << record.getLine() << PLOG_NSTR("] ");
+            ss << record.getMessage() << PLOG_NSTR("\n");
+
+            return ss.str();
+        }
+    };
+
+    class TxtFormatter : public TxtFormatterImpl<false> {};
+    class TxtFormatterUtcTime : public TxtFormatterImpl<true> {};
+}
diff --git a/include/plog/Helpers/AscDump.h b/include/plog/Helpers/AscDump.h
new file mode 100644
index 000000000..18b9a6f4f
--- /dev/null
+++ b/include/plog/Helpers/AscDump.h
@@ -0,0 +1,40 @@
+#pragma once
+#include <plog/Util.h>
+#include <cctype>
+
+namespace plog
+{
+    class AscDump
+    {
+    public:
+        AscDump(const void* ptr, size_t size)
+            : m_ptr(static_cast<const char*>(ptr))
+            , m_size(size)
+        {
+        }
+
+        friend util::nostringstream& operator<<(util::nostringstream& stream, const AscDump& ascDump);
+
+    private:
+        const char* m_ptr;
+        size_t m_size;
+    };
+
+    inline util::nostringstream& operator<<(util::nostringstream& stream, const AscDump& ascDump)
+    {
+        for (size_t i = 0; i < ascDump.m_size; ++i)
+        {
+            stream << (std::isprint(ascDump.m_ptr[i]) ? ascDump.m_ptr[i] : '.');
+        }
+
+        return stream;
+    }
+
+    inline AscDump ascdump(const void* ptr, size_t size) { return AscDump(ptr, size); }
+
+    template<class Container>
+    inline AscDump ascdump(const Container& container) { return AscDump(container.data(), container.size() * sizeof(*container.data())); }
+
+    template<class T, size_t N>
+    inline AscDump ascdump(const T (&arr)[N]) { return AscDump(arr, N * sizeof(*arr)); }
+}
diff --git a/include/plog/Helpers/HexDump.h b/include/plog/Helpers/HexDump.h
new file mode 100644
index 000000000..b0493d707
--- /dev/null
+++ b/include/plog/Helpers/HexDump.h
@@ -0,0 +1,79 @@
+#pragma once
+#include <plog/Util.h>
+#include <iomanip>
+
+namespace plog
+{
+    class HexDump
+    {
+    public:
+        HexDump(const void* ptr, size_t size)
+            : m_ptr(static_cast<const unsigned char*>(ptr))
+            , m_size(size)
+            , m_group(8)
+            , m_digitSeparator(" ")
+            , m_groupSeparator("  ")
+        {
+        }
+
+        HexDump& group(size_t group)
+        {
+            m_group = group;
+            return *this;
+        }
+
+        HexDump& separator(const char* digitSeparator)
+        {
+            m_digitSeparator = digitSeparator;
+            return *this;
+        }
+
+        HexDump& separator(const char* digitSeparator, const char* groupSeparator)
+        {
+            m_digitSeparator = digitSeparator;
+            m_groupSeparator = groupSeparator;
+            return *this;
+        }
+
+        friend util::nostringstream& operator<<(util::nostringstream& stream, const HexDump&);
+
+    private:
+        const unsigned char* m_ptr;
+        size_t m_size;
+        size_t m_group;
+        const char* m_digitSeparator;
+        const char* m_groupSeparator;
+    };
+
+    inline util::nostringstream& operator<<(util::nostringstream& stream, const HexDump& hexDump)
+    {
+        stream << std::hex << std::setfill(PLOG_NSTR('0'));
+
+        for (size_t i = 0; i < hexDump.m_size;)
+        {
+            stream << std::setw(2) << static_cast<int>(hexDump.m_ptr[i]);
+
+            if (++i < hexDump.m_size)
+            {
+                if (hexDump.m_group > 0 && i % hexDump.m_group == 0)
+                {
+                    stream << hexDump.m_groupSeparator;
+                }
+                else
+                {
+                    stream << hexDump.m_digitSeparator;
+                }
+            }
+        }
+
+        return stream;
+    }
+
+    inline HexDump hexdump(const void* ptr, size_t size) { return HexDump(ptr, size); }
+
+    template<class Container>
+    inline HexDump hexdump(const Container& container) { return HexDump(container.data(), container.size() * sizeof(*container.data())); }
+
+    template<class T, size_t N>
+    inline HexDump hexdump(const T (&arr)[N]) { return HexDump(arr, N * sizeof(*arr)); }
+}
diff --git a/include/plog/Helpers/PrintVar.h b/include/plog/Helpers/PrintVar.h
new file mode 100644
index 000000000..465e1938f
--- /dev/null
+++ b/include/plog/Helpers/PrintVar.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#define PLOG_IMPL_PRINT_VAR_1(a1) #a1 ": " << a1
+#define PLOG_IMPL_PRINT_VAR_2(a1, a2) PLOG_IMPL_PRINT_VAR_1(a1) PLOG_IMPL_PRINT_VAR_TAIL(a2)
+#define PLOG_IMPL_PRINT_VAR_3(a1, a2, a3) PLOG_IMPL_PRINT_VAR_2(a1, a2) PLOG_IMPL_PRINT_VAR_TAIL(a3)
+#define PLOG_IMPL_PRINT_VAR_4(a1, a2, a3, a4) PLOG_IMPL_PRINT_VAR_3(a1, a2, a3) PLOG_IMPL_PRINT_VAR_TAIL(a4)
+#define PLOG_IMPL_PRINT_VAR_5(a1, a2, a3, a4, a5) PLOG_IMPL_PRINT_VAR_4(a1, a2, a3, a4) PLOG_IMPL_PRINT_VAR_TAIL(a5)
+#define PLOG_IMPL_PRINT_VAR_6(a1, a2, a3, a4, a5, a6) PLOG_IMPL_PRINT_VAR_5(a1, a2, a3, a4, a5) PLOG_IMPL_PRINT_VAR_TAIL(a6)
+#define PLOG_IMPL_PRINT_VAR_7(a1, a2, a3, a4, a5, a6, a7) PLOG_IMPL_PRINT_VAR_6(a1, a2, a3, a4, a5, a6) PLOG_IMPL_PRINT_VAR_TAIL(a7)
+#define PLOG_IMPL_PRINT_VAR_8(a1, a2, a3, a4, a5, a6, a7, a8) PLOG_IMPL_PRINT_VAR_7(a1, a2, a3, a4, a5, a6, a7) PLOG_IMPL_PRINT_VAR_TAIL(a8)
+#define PLOG_IMPL_PRINT_VAR_9(a1, a2, a3, a4, a5, a6, a7, a8, a9) PLOG_IMPL_PRINT_VAR_8(a1, a2, a3, a4, a5, a6, a7, a8) PLOG_IMPL_PRINT_VAR_TAIL(a9)
+#define PLOG_IMPL_PRINT_VAR_TAIL(a) << ", " PLOG_IMPL_PRINT_VAR_1(a)
+
+#define PLOG_IMPL_PRINT_VAR_EXPAND(x) x
+
+#ifdef __GNUC__
+#pragma GCC system_header // disable warning: variadic macros are a C99 feature
+#endif
+
+#define PLOG_IMPL_PRINT_VAR_GET_MACRO(x1, x2, x3, x4, x5, x6, x7, x8, x9, NAME, ...) NAME
+
+#define PLOG_PRINT_VAR(...) PLOG_IMPL_PRINT_VAR_EXPAND(PLOG_IMPL_PRINT_VAR_GET_MACRO(__VA_ARGS__,\
+    PLOG_IMPL_PRINT_VAR_9, PLOG_IMPL_PRINT_VAR_8, PLOG_IMPL_PRINT_VAR_7, PLOG_IMPL_PRINT_VAR_6, PLOG_IMPL_PRINT_VAR_5,\
+    PLOG_IMPL_PRINT_VAR_4, PLOG_IMPL_PRINT_VAR_3, PLOG_IMPL_PRINT_VAR_2, PLOG_IMPL_PRINT_VAR_1, UNUSED)(__VA_ARGS__))
diff --git a/include/plog/Init.h b/include/plog/Init.h
new file mode 100644
index 000000000..615c41d6c
--- /dev/null
+++ b/include/plog/Init.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <plog/Logger.h>
+
+namespace plog
+{
+    template<int instanceId>
+    PLOG_LINKAGE_HIDDEN inline Logger<instanceId>& init(Severity maxSeverity = none, IAppender* appender = NULL)
+    {
+        static Logger<instanceId> logger(maxSeverity);
+        return appender ? logger.addAppender(appender) : logger;
+    }
+
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity = none, IAppender* appender = NULL)
+    {
+        return init<PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, appender);
+    }
+}
diff --git a/include/plog/Initializers/ConsoleInitializer.h b/include/plog/Initializers/ConsoleInitializer.h
new file mode 100644
index 000000000..5b504abd5
--- /dev/null
+++ b/include/plog/Initializers/ConsoleInitializer.h
@@ -0,0 +1,22 @@
+#pragma once
+#include <plog/Appenders/ColorConsoleAppender.h>
+#include <plog/Init.h>
+
+namespace plog
+{
+    //////////////////////////////////////////////////////////////////////////
+    // ColorConsoleAppender with any Formatter
+
+    template<class Formatter, int instanceId>
+    PLOG_LINKAGE_HIDDEN inline Logger<instanceId>& init(Severity maxSeverity, OutputStream outputStream)
+    {
+        static ColorConsoleAppender<Formatter> appender(outputStream);
+        return init<instanceId>(maxSeverity, &appender);
+    }
+
+    template<class Formatter>
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity, OutputStream outputStream)
+    {
+        return init<Formatter, PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, outputStream);
+    }
+}
diff --git a/include/plog/Initializers/RollingFileInitializer.h b/include/plog/Initializers/RollingFileInitializer.h
new file mode 100644
index 000000000..dc0adda14
--- /dev/null
+++ b/include/plog/Initializers/RollingFileInitializer.h
@@ -0,0 +1,80 @@
+#pragma once
+#include <plog/Appenders/RollingFileAppender.h>
+#include <plog/Formatters/TxtFormatter.h>
+#include <plog/Formatters/CsvFormatter.h>
+#include <plog/Init.h>
+#include <cstring>
+
+namespace plog
+{
+    //////////////////////////////////////////////////////////////////////////
+    // RollingFileAppender with any Formatter
+
+    template<class Formatter, int instanceId>
+    PLOG_LINKAGE_HIDDEN inline Logger<instanceId>& init(Severity maxSeverity, const util::nchar* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        static RollingFileAppender<Formatter> rollingFileAppender(fileName, maxFileSize, maxFiles);
+        return init<instanceId>(maxSeverity, &rollingFileAppender);
+    }
+
+    template<class Formatter>
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity, const util::nchar* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<Formatter, PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, fileName, maxFileSize, maxFiles);
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // RollingFileAppender with TXT/CSV chosen by file extension
+
+    namespace
+    {
+        inline bool isCsv(const util::nchar* fileName)
+        {
+            const util::nchar* dot = util::findExtensionDot(fileName);
+#if PLOG_CHAR_IS_UTF8
+            return dot && 0 == std::strcmp(dot, ".csv");
+#else
+            return dot && 0 == std::wcscmp(dot, L".csv");
+#endif
+        }
+    }
+
+    template<int instanceId>
+    inline Logger<instanceId>& init(Severity maxSeverity, const util::nchar* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return isCsv(fileName) ? init<CsvFormatter, instanceId>(maxSeverity, fileName, maxFileSize, maxFiles) : init<TxtFormatter, instanceId>(maxSeverity, fileName, maxFileSize, maxFiles);
+    }
+
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity, const util::nchar* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, fileName, maxFileSize, maxFiles);
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // CHAR variants for Windows
+
+#if defined(_WIN32) && !PLOG_CHAR_IS_UTF8
+    template<class Formatter, int instanceId>
+    inline Logger<instanceId>& init(Severity maxSeverity, const char* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<Formatter, instanceId>(maxSeverity, util::toWide(fileName).c_str(), maxFileSize, maxFiles);
+    }
+
+    template<class Formatter>
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity, const char* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<Formatter, PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, fileName, maxFileSize, maxFiles);
+    }
+
+    template<int instanceId>
+    inline Logger<instanceId>& init(Severity maxSeverity, const char* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<instanceId>(maxSeverity, util::toWide(fileName).c_str(), maxFileSize, maxFiles);
+    }
+
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>& init(Severity maxSeverity, const char* fileName, size_t maxFileSize = 0, int maxFiles = 0)
+    {
+        return init<PLOG_DEFAULT_INSTANCE_ID>(maxSeverity, fileName, maxFileSize, maxFiles);
+    }
+#endif
+}
diff --git a/include/plog/LICENSE b/include/plog/LICENSE
new file mode 100644
index 000000000..8a91a0aee
--- /dev/null
+++ b/include/plog/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Sergey Podobry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/include/plog/Log.h b/include/plog/Log.h
new file mode 100644
index 000000000..127cb9d6b
--- /dev/null
+++ b/include/plog/Log.h
@@ -0,0 +1,211 @@
+//////////////////////////////////////////////////////////////////////////
+//  Plog - portable and simple log for C++
+//  Documentation and sources: https://github.com/SergiusTheBest/plog
+//  License: MIT, https://choosealicense.com/licenses/mit
+
+#pragma once
+#include <plog/Logger.h>
+
+//////////////////////////////////////////////////////////////////////////
+// Helper macros that get context info
+
+#if defined(PLOG_ENABLE_GET_THIS) && defined(_MSC_VER) && _MSC_VER >= 1600 && !defined(__INTELLISENSE__) && !defined(__INTEL_COMPILER) && !defined(__llvm__) && !defined(__RESHARPER__) // >= Visual Studio 2010, skip IntelliSense, Intel Compiler, Clang Code Model and ReSharper
+#   define PLOG_GET_THIS()      __if_exists(this) { this } __if_not_exists(this) { 0 }
+#else
+#   define PLOG_GET_THIS()      reinterpret_cast<void*>(0)
+#endif
+
+#ifdef PLOG_NO_CAPTURE_FUNCTION_NAME
+#   define PLOG_GET_FUNC()      ""
+#elif defined(_MSC_VER)
+#   define PLOG_GET_FUNC()      __FUNCTION__
+#elif defined(__BORLANDC__)
+#   define PLOG_GET_FUNC()      __FUNC__
+#else
+#   define PLOG_GET_FUNC()      __PRETTY_FUNCTION__
+#endif
+
+#ifdef PLOG_CAPTURE_FILE
+#   define PLOG_GET_FILE()      __FILE__
+#else
+#   define PLOG_GET_FILE()      ""
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Log severity level checker
+
+#ifdef PLOG_DISABLE_LOGGING
+#   ifdef _MSC_VER
+#       define IF_PLOG_(instanceId, severity)  __pragma(warning(push)) __pragma(warning(disable:4127)) if (true) {;} else __pragma(warning(pop)) // conditional expression is constant
+#   else
+#       define IF_PLOG_(instanceId, severity)   if (true) {;} else
+#   endif
+#else
+#   define IF_PLOG_(instanceId, severity)   if (!plog::get<instanceId>() || !plog::get<instanceId>()->checkSeverity(severity)) {;} else
+#endif
+
+#define IF_PLOG(severity)                IF_PLOG_(PLOG_DEFAULT_INSTANCE_ID, severity)
+
+//////////////////////////////////////////////////////////////////////////
+// Main logging macros
+
+#ifdef PLOG_MESSAGE_PREFIX
+#   define PLOG_PRINT_MESSAGE_PREFIX()    << PLOG_MESSAGE_PREFIX
+#else
+#   define PLOG_PRINT_MESSAGE_PREFIX()
+#endif
+
+#define PLOG_(instanceId, severity)      IF_PLOG_(instanceId, severity) (*plog::get<instanceId>()) += \
+    plog::Record(severity, PLOG_GET_FUNC(), __LINE__, PLOG_GET_FILE(), PLOG_GET_THIS(), instanceId).ref() PLOG_PRINT_MESSAGE_PREFIX()
+#define PLOG(severity)                   PLOG_(PLOG_DEFAULT_INSTANCE_ID, severity)
+
+#define PLOG_VERBOSE                     PLOG(plog::verbose)
+#define PLOG_DEBUG                       PLOG(plog::debug)
+#define PLOG_INFO                        PLOG(plog::info)
+#define PLOG_WARNING                     PLOG(plog::warning)
+#define PLOG_ERROR                       PLOG(plog::error)
+#define PLOG_FATAL                       PLOG(plog::fatal)
+#define PLOG_NONE                        PLOG(plog::none)
+
+#define PLOG_VERBOSE_(instanceId)        PLOG_(instanceId, plog::verbose)
+#define PLOG_DEBUG_(instanceId)          PLOG_(instanceId, plog::debug)
+#define PLOG_INFO_(instanceId)           PLOG_(instanceId, plog::info)
+#define PLOG_WARNING_(instanceId)        PLOG_(instanceId, plog::warning)
+#define PLOG_ERROR_(instanceId)          PLOG_(instanceId, plog::error)
+#define PLOG_FATAL_(instanceId)          PLOG_(instanceId, plog::fatal)
+#define PLOG_NONE_(instanceId)           PLOG_(instanceId, plog::none)
+
+#define PLOGV                            PLOG_VERBOSE
+#define PLOGD                            PLOG_DEBUG
+#define PLOGI                            PLOG_INFO
+#define PLOGW                            PLOG_WARNING
+#define PLOGE                            PLOG_ERROR
+#define PLOGF                            PLOG_FATAL
+#define PLOGN                            PLOG_NONE
+
+#define PLOGV_(instanceId)               PLOG_VERBOSE_(instanceId)
+#define PLOGD_(instanceId)               PLOG_DEBUG_(instanceId)
+#define PLOGI_(instanceId)               PLOG_INFO_(instanceId)
+#define PLOGW_(instanceId)               PLOG_WARNING_(instanceId)
+#define PLOGE_(instanceId)               PLOG_ERROR_(instanceId)
+#define PLOGF_(instanceId)               PLOG_FATAL_(instanceId)
+#define PLOGN_(instanceId)               PLOG_NONE_(instanceId)
+
+//////////////////////////////////////////////////////////////////////////
+// Conditional logging macros
+
+#define PLOG_IF_(instanceId, severity, condition)  if (!(condition)) {;} else PLOG_(instanceId, severity)
+#define PLOG_IF(severity, condition)               PLOG_IF_(PLOG_DEFAULT_INSTANCE_ID, severity, condition)
+
+#define PLOG_VERBOSE_IF(condition)               PLOG_IF(plog::verbose, condition)
+#define PLOG_DEBUG_IF(condition)                 PLOG_IF(plog::debug, condition)
+#define PLOG_INFO_IF(condition)                  PLOG_IF(plog::info, condition)
+#define PLOG_WARNING_IF(condition)               PLOG_IF(plog::warning, condition)
+#define PLOG_ERROR_IF(condition)                 PLOG_IF(plog::error, condition)
+#define PLOG_FATAL_IF(condition)                 PLOG_IF(plog::fatal, condition)
+#define PLOG_NONE_IF(condition)                  PLOG_IF(plog::none, condition)
+
+#define PLOG_VERBOSE_IF_(instanceId, condition)  PLOG_IF_(instanceId, plog::verbose, condition)
+#define PLOG_DEBUG_IF_(instanceId, condition)    PLOG_IF_(instanceId, plog::debug, condition)
+#define PLOG_INFO_IF_(instanceId, condition)     PLOG_IF_(instanceId, plog::info, condition)
+#define PLOG_WARNING_IF_(instanceId, condition)  PLOG_IF_(instanceId, plog::warning, condition)
+#define PLOG_ERROR_IF_(instanceId, condition)    PLOG_IF_(instanceId, plog::error, condition)
+#define PLOG_FATAL_IF_(instanceId, condition)    PLOG_IF_(instanceId, plog::fatal, condition)
+#define PLOG_NONE_IF_(instanceId, condition)     PLOG_IF_(instanceId, plog::none, condition)
+
+#define PLOGV_IF(condition)                      PLOG_VERBOSE_IF(condition)
+#define PLOGD_IF(condition)                      PLOG_DEBUG_IF(condition)
+#define PLOGI_IF(condition)                      PLOG_INFO_IF(condition)
+#define PLOGW_IF(condition)                      PLOG_WARNING_IF(condition)
+#define PLOGE_IF(condition)                      PLOG_ERROR_IF(condition)
+#define PLOGF_IF(condition)                      PLOG_FATAL_IF(condition)
+#define PLOGN_IF(condition)                      PLOG_NONE_IF(condition)
+
+#define PLOGV_IF_(instanceId, condition)         PLOG_VERBOSE_IF_(instanceId, condition)
+#define PLOGD_IF_(instanceId, condition)         PLOG_DEBUG_IF_(instanceId, condition)
+#define PLOGI_IF_(instanceId, condition)         PLOG_INFO_IF_(instanceId, condition)
+#define PLOGW_IF_(instanceId, condition)         PLOG_WARNING_IF_(instanceId, condition)
+#define PLOGE_IF_(instanceId, condition)         PLOG_ERROR_IF_(instanceId, condition)
+#define PLOGF_IF_(instanceId, condition)         PLOG_FATAL_IF_(instanceId, condition)
+#define PLOGN_IF_(instanceId, condition)         PLOG_NONE_IF_(instanceId, condition)
+
+// Old macro names for downward compatibility. To bypass including these macro names, add
+// #define PLOG_OMIT_LOG_DEFINES before #include <plog/Log.h>
+#ifndef PLOG_OMIT_LOG_DEFINES
+
+//////////////////////////////////////////////////////////////////////////
+// Main logging macros - can be changed later to point at macros for a different logging package
+
+#define LOG_(instanceId, severity)      PLOG_(instanceId, severity)
+#define LOG(severity)                   PLOG(severity)
+
+#define LOG_VERBOSE                     PLOG_VERBOSE
+#define LOG_DEBUG                       PLOG_DEBUG
+#define LOG_INFO                        PLOG_INFO
+#define LOG_WARNING                     PLOG_WARNING
+#define LOG_ERROR                       PLOG_ERROR
+#define LOG_FATAL                       PLOG_FATAL
+#define LOG_NONE                        PLOG_NONE
+
+#define LOG_VERBOSE_(instanceId)        PLOG_VERBOSE_(instanceId)
+#define LOG_DEBUG_(instanceId)          PLOG_DEBUG_(instanceId)
+#define LOG_INFO_(instanceId)           PLOG_INFO_(instanceId)
+#define LOG_WARNING_(instanceId)        PLOG_WARNING_(instanceId)
+#define LOG_ERROR_(instanceId)          PLOG_ERROR_(instanceId)
+#define LOG_FATAL_(instanceId)          PLOG_FATAL_(instanceId)
+#define LOG_NONE_(instanceId)           PLOG_NONE_(instanceId)
+
+#define LOGV                            PLOGV
+#define LOGD                            PLOGD
+#define LOGI                            PLOGI
+#define LOGW                            PLOGW
+#define LOGE                            PLOGE
+#define LOGF                            PLOGF
+#define LOGN                            PLOGN
+
+#define LOGV_(instanceId)               PLOGV_(instanceId)
+#define LOGD_(instanceId)               PLOGD_(instanceId)
+#define LOGI_(instanceId)               PLOGI_(instanceId)
+#define LOGW_(instanceId)               PLOGW_(instanceId)
+#define LOGE_(instanceId)               PLOGE_(instanceId)
+#define LOGF_(instanceId)               PLOGF_(instanceId)
+#define LOGN_(instanceId)               PLOGN_(instanceId)
+
+//////////////////////////////////////////////////////////////////////////
+// Conditional logging macros
+
+#define LOG_IF_(instanceId, severity, condition)  PLOG_IF_(instanceId, severity, condition)
+#define LOG_IF(severity, condition)               PLOG_IF(severity, condition)
+
+#define LOG_VERBOSE_IF(condition)               PLOG_VERBOSE_IF(condition)
+#define LOG_DEBUG_IF(condition)                 PLOG_DEBUG_IF(condition)
+#define LOG_INFO_IF(condition)                  PLOG_INFO_IF(condition)
+#define LOG_WARNING_IF(condition)               PLOG_WARNING_IF(condition)
+#define LOG_ERROR_IF(condition)                 PLOG_ERROR_IF(condition)
+#define LOG_FATAL_IF(condition)                 PLOG_FATAL_IF(condition)
+#define LOG_NONE_IF(condition)                  PLOG_NONE_IF(condition)
+
+#define LOG_VERBOSE_IF_(instanceId, condition)  PLOG_VERBOSE_IF_(instanceId, condition)
+#define LOG_DEBUG_IF_(instanceId, condition)    PLOG_DEBUG_IF_(instanceId, condition)
+#define LOG_INFO_IF_(instanceId, condition)     PLOG_INFO_IF_(instanceId, condition)
+#define LOG_WARNING_IF_(instanceId, condition)  PLOG_WARNING_IF_(instanceId, condition)
+#define LOG_ERROR_IF_(instanceId, condition)    PLOG_ERROR_IF_(instanceId, condition)
+#define LOG_FATAL_IF_(instanceId, condition)    PLOG_FATAL_IF_(instanceId, condition)
+#define LOG_NONE_IF_(instanceId, condition)     PLOG_NONE_IF_(instanceId, condition)
+
+#define LOGV_IF(condition)                      PLOGV_IF(condition)
+#define LOGD_IF(condition)                      PLOGD_IF(condition)
+#define LOGI_IF(condition)                      PLOGI_IF(condition)
+#define LOGW_IF(condition)                      PLOGW_IF(condition)
+#define LOGE_IF(condition)                      PLOGE_IF(condition)
+#define LOGF_IF(condition)                      PLOGF_IF(condition)
+#define LOGN_IF(condition)                      PLOGN_IF(condition)
+
+#define LOGV_IF_(instanceId, condition)         PLOGV_IF_(instanceId, condition)
+#define LOGD_IF_(instanceId, condition)         PLOGD_IF_(instanceId, condition)
+#define LOGI_IF_(instanceId, condition)         PLOGI_IF_(instanceId, condition)
+#define LOGW_IF_(instanceId, condition)         PLOGW_IF_(instanceId, condition)
+#define LOGE_IF_(instanceId, condition)         PLOGE_IF_(instanceId, condition)
+#define LOGF_IF_(instanceId, condition)         PLOGF_IF_(instanceId, condition)
+#define LOGN_IF_(instanceId, condition)         PLOGN_IF_(instanceId, condition)
+#endif
diff --git a/include/plog/Logger.h b/include/plog/Logger.h
new file mode 100644
index 000000000..0e116e4c6
--- /dev/null
+++ b/include/plog/Logger.h
@@ -0,0 +1,84 @@
+#pragma once
+#include <plog/Appenders/IAppender.h>
+#include <plog/Util.h>
+#include <vector>
+
+#ifdef PLOG_DEFAULT_INSTANCE // for backward compatibility
+#   define PLOG_DEFAULT_INSTANCE_ID PLOG_DEFAULT_INSTANCE
+#endif
+
+#ifndef PLOG_DEFAULT_INSTANCE_ID
+#   define PLOG_DEFAULT_INSTANCE_ID 0
+#endif
+
+namespace plog
+{
+    template<int instanceId>
+    class PLOG_LINKAGE Logger : public util::Singleton<Logger<instanceId> >, public IAppender
+    {
+    public:
+        Logger(Severity maxSeverity = none) : m_maxSeverity(maxSeverity)
+        {
+        }
+
+        Logger& addAppender(IAppender* appender)
+        {
+            assert(appender != this);
+            m_appenders.push_back(appender);
+            return *this;
+        }
+
+        Severity getMaxSeverity() const
+        {
+            return m_maxSeverity;
+        }
+
+        void setMaxSeverity(Severity severity)
+        {
+            m_maxSeverity = severity;
+        }
+
+        bool checkSeverity(Severity severity) const
+        {
+            return severity <= m_maxSeverity;
+        }
+
+        virtual void write(const Record& record) PLOG_OVERRIDE
+        {
+            if (checkSeverity(record.getSeverity()))
+            {
+                *this += record;
+            }
+        }
+
+        void operator+=(const Record& record)
+        {
+            for (std::vector<IAppender*>::iterator it = m_appenders.begin(); it != m_appenders.end(); ++it)
+            {
+                (*it)->write(record);
+            }
+        }
+
+    private:
+        Severity m_maxSeverity;
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   pragma warning(disable:4251) // needs to have dll-interface to be used by clients of class
+#endif
+        std::vector<IAppender*> m_appenders;
+#ifdef _MSC_VER
+#   pragma warning(pop)
+#endif
+    };
+
+    template<int instanceId>
+    inline Logger<instanceId>* get()
+    {
+        return Logger<instanceId>::getInstance();
+    }
+
+    inline Logger<PLOG_DEFAULT_INSTANCE_ID>* get()
+    {
+        return Logger<PLOG_DEFAULT_INSTANCE_ID>::getInstance();
+    }
+}
diff --git a/include/plog/Record.h b/include/plog/Record.h
new file mode 100644
index 000000000..c919e3aa6
--- /dev/null
+++ b/include/plog/Record.h
@@ -0,0 +1,465 @@
+#pragma once
+#include <cstdarg>
+#include <plog/Severity.h>
+#include <plog/Util.h>
+
+#ifdef __cplusplus_cli
+#include <vcclr.h>  // For PtrToStringChars
+#endif
+
+namespace plog
+{
+    namespace detail
+    {
+#if !defined(_MSC_VER) || _MSC_VER > 1400 // MSVC 2005 doesn't understand `enableIf`, so drop all `meta`
+        namespace meta
+        {
+            template<class T>
+            inline T& declval()
+            {
+#ifdef __INTEL_COMPILER
+#    pragma warning(suppress: 327) // NULL reference is not allowed
+#endif
+                return *reinterpret_cast<T*>(0);
+            }
+
+            template<bool B, class T = void>
+            struct enableIf {};
+
+            template<class T>
+            struct enableIf<true, T> { typedef T type; };
+
+            struct No  { char a[1]; };
+            struct Yes { char a[2]; };
+
+            template <class From, class To>
+            struct isConvertible
+            {
+                // `+ sizeof(U*)` is required for GCC 4.5-4.7
+                template<class U>
+                static typename enableIf<!!(sizeof(static_cast<To>(meta::declval<U>())) + sizeof(U*)), Yes>::type test(int);
+
+                template<class U>
+                static No test(...);
+
+                enum { value = sizeof(test<From>(0)) == sizeof(Yes) };
+            };
+
+            template <class T>
+            struct isConvertibleToString : isConvertible<T, std::string> {};
+
+#if PLOG_ENABLE_WCHAR_INPUT
+            template <class T>
+            struct isConvertibleToWString : isConvertible<T, std::wstring> {};
+#endif
+
+            template <class T>
+            struct isContainer
+            {
+                template<class U>
+                static typename meta::enableIf<!!(sizeof(
+#if defined(_MSC_VER) && _MSC_VER < 1700 // MSVC 2010 doesn't understand `typename T::const_iterator`
+                    meta::declval<U>().begin()) + sizeof(meta::declval<U>().end()
+#else
+                    typename U::const_iterator
+#endif
+                    )), Yes>::type test(int);
+
+                template<class U>
+                static No test(...);
+
+                enum { value = sizeof(test<T>(0)) == sizeof(Yes) };
+            };
+
+            // Detects `std::filesystem::path` and `boost::filesystem::path`. They look like containers
+            // but we don't want to treat them as containers, so we use this detector to filter them out.
+            template <class T>
+            struct isFilesystemPath
+            {
+                template<class U>
+                static typename meta::enableIf<!!(sizeof(meta::declval<U>().preferred_separator)), Yes>::type test(int);
+
+                template<class U>
+                static No test(...);
+
+                enum { value = sizeof(test<T>(0)) == sizeof(Yes) };
+            };
+        }
+#endif
+
+        //////////////////////////////////////////////////////////////////////////
+        // Stream output operators as free functions
+
+#if PLOG_ENABLE_WCHAR_INPUT
+        inline void operator<<(util::nostringstream& stream, const wchar_t* data)
+        {
+            data = data ? data : L"(null)";
+
+#   ifdef _WIN32
+#       if PLOG_CHAR_IS_UTF8
+            std::operator<<(stream, util::toNarrow(data, codePage::kUTF8));
+#       else
+            std::operator<<(stream, data);
+#       endif
+#   else
+            std::operator<<(stream, util::toNarrow(data));
+#   endif
+        }
+
+        inline void operator<<(util::nostringstream& stream, wchar_t* data)
+        {
+            plog::detail::operator<<(stream, const_cast<const wchar_t*>(data));
+        }
+
+        inline void operator<<(util::nostringstream& stream, const std::wstring& data)
+        {
+            plog::detail::operator<<(stream, data.c_str());
+        }
+#endif
+
+        inline void operator<<(util::nostringstream& stream, const char* data)
+        {
+            data = data ? data : "(null)";
+
+#if defined(_WIN32) && defined(__BORLANDC__)
+#   if PLOG_CHAR_IS_UTF8
+            stream << data;
+#   else
+            stream << util::toWide(data);
+#   endif
+#elif defined(_WIN32)
+#   if PLOG_CHAR_IS_UTF8
+            std::operator<<(stream, data);
+#   else
+            std::operator<<(stream, util::toWide(data));
+#   endif
+#else
+            std::operator<<(stream, data);
+#endif
+        }
+
+        inline void operator<<(util::nostringstream& stream, char* data)
+        {
+            plog::detail::operator<<(stream, const_cast<const char*>(data));
+        }
+
+        inline void operator<<(util::nostringstream& stream, const std::string& data)
+        {
+            plog::detail::operator<<(stream, data.c_str());
+        }
+
+#ifdef __cpp_char8_t
+        inline void operator<<(util::nostringstream& stream, const char8_t* data)
+        {
+#   if PLOG_CHAR_IS_UTF8
+            plog::detail::operator<<(stream, reinterpret_cast<const char*>(data));
+#   else
+            plog::detail::operator<<(stream, util::toWide(reinterpret_cast<const char*>(data), codePage::kUTF8));
+#   endif
+        }
+#endif //__cpp_char8_t
+
+        // Print `std::pair`
+        template<class T1, class T2>
+        inline void operator<<(util::nostringstream& stream, const std::pair<T1, T2>& data)
+        {
+            stream << data.first;
+            stream << ":";
+            stream << data.second;
+        }
+
+#if defined(__clang__) || !defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 // skip for GCC < 4.5 due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=38600
+#if !defined(_MSC_VER) || _MSC_VER > 1400 // MSVC 2005 doesn't understand `enableIf`, so drop all `meta`
+        // Print data that can be casted to `std::string`
+        template<class T>
+        inline typename meta::enableIf<meta::isConvertibleToString<T>::value, void>::type operator<<(util::nostringstream& stream, const T& data)
+        {
+            plog::detail::operator<<(stream, static_cast<std::string>(data));
+        }
+
+#if PLOG_ENABLE_WCHAR_INPUT
+        // Print data that can be casted to `std::wstring`
+        template<class T>
+        inline typename meta::enableIf<meta::isConvertibleToWString<T>::value, void>::type operator<<(util::nostringstream& stream, const T& data)
+        {
+            plog::detail::operator<<(stream, static_cast<std::wstring>(data));
+        }
+#endif
+
+        // Print std containers
+        template<class T>
+        inline typename meta::enableIf<meta::isContainer<T>::value &&
+            !meta::isConvertibleToString<T>::value &&
+#if PLOG_ENABLE_WCHAR_INPUT
+            !meta::isConvertibleToWString<T>::value &&
+#endif
+            !meta::isFilesystemPath<T>::value, void>::type operator<<(util::nostringstream& stream, const T& data)
+        {
+            stream << "[";
+
+            for (typename T::const_iterator it = data.begin(); it != data.end();)
+            {
+                stream << *it;
+
+                if (++it == data.end())
+                {
+                    break;
+                }
+
+                stream << ", ";
+            }
+
+            stream << "]";
+        }
+#endif
+#endif
+
+#ifdef __cplusplus_cli
+        // Print managed C++ `System::String^`
+        inline void operator<<(util::nostringstream& stream, System::String^ data)
+        {
+            cli::pin_ptr<const System::Char> ptr = PtrToStringChars(data);
+            plog::detail::operator<<(stream, static_cast<const wchar_t*>(ptr));
+        }
+#endif
+
+#if PLOG_ENABLE_WCHAR_INPUT && (!defined(_MSC_VER) || _MSC_VER > 1400) // MSVC 2005 doesn't understand `enableIf`, so drop all `meta`
+        namespace meta
+        {
+            template<bool Value>
+            struct valueType { enum { value = Value }; };
+
+            template<class T, class Stream>
+            inline No operator<<(Stream&, const T&);
+
+            template<class T, class Stream>
+            struct isStreamable : valueType<sizeof(operator<<(meta::declval<Stream>(), meta::declval<const T>())) != sizeof(No)> {};
+
+            template<class Stream>
+            struct isStreamable<std::ios_base& PLOG_CDECL (std::ios_base&), Stream> : valueType<true> {};
+
+            template<class Stream, size_t N>
+            struct isStreamable<wchar_t[N], Stream> : valueType<false> {};
+
+            template<class Stream, size_t N>
+            struct isStreamable<const wchar_t[N], Stream> : valueType<false> {};
+
+            // meta doesn't work well for deleted functions and C++20 has `operator<<(std::ostream&, const wchar_t*) = delete` so explicitly define it
+            template<>
+            struct isStreamable<const wchar_t*, std::ostream> : valueType<false> {};
+
+#   ifdef __cpp_char8_t
+            // meta doesn't work well for deleted functions and C++20 has `operator<<(std::ostream&, const char8_t*) = delete` so explicitly define it
+            template<class Stream, size_t N>
+            struct isStreamable<char8_t[N], Stream> : valueType<false> {};
+
+            template<class Stream>
+            struct isStreamable<const char8_t*, Stream> : valueType<false> {};
+#   endif //__cpp_char8_t
+        }
+
+#   if PLOG_CHAR_IS_UTF8
+        // Print types that can be streamed into `std::owstringstream` but not into `std::ostringstream` when we use UTF-8 on Windows
+        template<class T>
+        inline typename meta::enableIf<meta::isStreamable<T, std::wostream>::value &&
+            !meta::isStreamable<T, std::ostream>::value &&
+            !meta::isConvertibleToWString<T>::value, void>::type operator<<(std::ostringstream& stream, const T& data)
+        {
+            std::wostringstream ss;
+            ss << data;
+            stream << ss.str();
+        }
+#   else
+        // Print types that can be streamed into `std::ostringstream` but not into `std::owstringstream` when we use `wchar_t` on Windows
+        template<class T>
+        inline typename meta::enableIf<meta::isStreamable<T, std::ostream>::value &&
+            !meta::isStreamable<T, std::wostream>::value &&
+            !meta::isConvertibleToString<T>::value, void>::type operator<<(std::wostringstream& stream, const T& data)
+        {
+            std::ostringstream ss;
+            ss << data;
+            stream << ss.str();
+        }
+#   endif
+#endif
+    }
+
+    class Record
+    {
+    public:
+        Record(Severity severity, const char* func, size_t line, const char* file, const void* object, int instanceId)
+            : m_severity(severity), m_tid(util::gettid()), m_object(object), m_line(line), m_func(func), m_file(file), m_instanceId(instanceId)
+        {
+            util::ftime(&m_time);
+        }
+
+        Record& ref()
+        {
+            return *this;
+        }
+
+        //////////////////////////////////////////////////////////////////////////
+        // Stream output operators
+
+        Record& operator<<(char data)
+        {
+            char str[] = { data, 0 };
+            return *this << str;
+        }
+
+#if PLOG_ENABLE_WCHAR_INPUT
+        Record& operator<<(wchar_t data)
+        {
+            wchar_t str[] = { data, 0 };
+            return *this << str;
+        }
+#endif
+
+        Record& operator<<(util::nostream& (PLOG_CDECL *data)(util::nostream&))
+        {
+            m_message << data;
+            return *this;
+        }
+
+#ifdef QT_VERSION
+        Record& operator<<(const QString& data)
+        {
+#   if PLOG_CHAR_IS_UTF8
+            return *this << data.toStdString();
+#   else
+            return *this << data.toStdWString();
+#   endif
+        }
+
+#   if QT_VERSION < 0x060000
+        Record& operator<<(const QStringRef& data)
+        {
+            return *this << data.toString();
+        }
+#   endif
+
+#   ifdef QSTRINGVIEW_H
+        Record& operator<<(QStringView data)
+        {
+            return *this << data.toString();
+        }
+#   endif
+#endif
+
+        template<typename T>
+        Record& operator<<(const T& data)
+        {
+            using namespace plog::detail;
+
+            m_message << data;
+            return *this;
+        }
+
+#ifndef __cplusplus_cli
+        Record& printf(const char* format, ...)
+        {
+            using namespace util;
+
+            char* str = NULL;
+            va_list ap;
+
+            va_start(ap, format);
+            int len = vasprintf(&str, format, ap);
+            static_cast<void>(len);
+            va_end(ap);
+
+            *this << str;
+            free(str);
+
+            return *this;
+        }
+
+#ifdef _WIN32
+        Record& printf(const wchar_t* format, ...)
+        {
+            using namespace util;
+
+            wchar_t* str = NULL;
+            va_list ap;
+
+            va_start(ap, format);
+            int len = vaswprintf(&str, format, ap);
+            static_cast<void>(len);
+            va_end(ap);
+
+            *this << str;
+            free(str);
+
+            return *this;
+        }
+#endif
+#endif //__cplusplus_cli
+
+        //////////////////////////////////////////////////////////////////////////
+        // Getters
+
+        virtual const util::Time& getTime() const
+        {
+            return m_time;
+        }
+
+        virtual Severity getSeverity() const
+        {
+            return m_severity;
+        }
+
+        virtual unsigned int getTid() const
+        {
+            return m_tid;
+        }
+
+        virtual const void* getObject() const
+        {
+            return m_object;
+        }
+
+        virtual size_t getLine() const
+        {
+            return m_line;
+        }
+
+        virtual const util::nchar* getMessage() const
+        {
+            m_messageStr = m_message.str();
+            return m_messageStr.c_str();
+        }
+
+        virtual const char* getFunc() const
+        {
+            m_funcStr = util::processFuncName(m_func);
+            return m_funcStr.c_str();
+        }
+
+        virtual const char* getFile() const
+        {
+            return m_file;
+        }
+
+        virtual ~Record() // virtual destructor to satisfy -Wnon-virtual-dtor warning
+        {
+        }
+
+        virtual int getInstanceId() const
+        {
+            return m_instanceId;
+        }
+
+    private:
+        util::Time              m_time;
+        const Severity          m_severity;
+        const unsigned int      m_tid;
+        const void* const       m_object;
+        const size_t            m_line;
+        util::nostringstream    m_message;
+        const char* const       m_func;
+        const char* const       m_file;
+        const int               m_instanceId;
+        mutable std::string     m_funcStr;
+        mutable util::nstring   m_messageStr;
+    };
+}
diff --git a/include/plog/Severity.h b/include/plog/Severity.h
new file mode 100644
index 000000000..446768e8f
--- /dev/null
+++ b/include/plog/Severity.h
@@ -0,0 +1,61 @@
+#pragma once
+#include <cctype>
+
+namespace plog
+{
+    enum Severity
+    {
+        none = 0,
+        fatal = 1,
+        error = 2,
+        warning = 3,
+        info = 4,
+        debug = 5,
+        verbose = 6
+    };
+
+#ifdef _MSC_VER
+#   pragma warning(suppress: 26812) //  Prefer 'enum class' over 'enum'
+#endif
+    inline const char* severityToString(Severity severity)
+    {
+        switch (severity)
+        {
+        case fatal:
+            return "FATAL";
+        case error:
+            return "ERROR";
+        case warning:
+            return "WARN";
+        case info:
+            return "INFO";
+        case debug:
+            return "DEBUG";
+        case verbose:
+            return "VERB";
+        default:
+            return "NONE";
+        }
+    }
+
+    inline Severity severityFromString(const char* str)
+    {
+        switch (std::toupper(str[0]))
+        {
+        case 'F':
+            return fatal;
+        case 'E':
+            return error;
+        case 'W':
+            return warning;
+        case 'I':
+            return info;
+        case 'D':
+            return debug;
+        case 'V':
+            return verbose;
+        default:
+            return none;
+        }
+    }
+}
diff --git a/include/plog/Util.h b/include/plog/Util.h
new file mode 100644
index 000000000..ec319a10c
--- /dev/null
+++ b/include/plog/Util.h
@@ -0,0 +1,635 @@
+#pragma once
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cstdlib>
+#include <sstream>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#ifndef PLOG_ENABLE_WCHAR_INPUT
+#   ifdef _WIN32
+#       define PLOG_ENABLE_WCHAR_INPUT 1
+#   else
+#       define PLOG_ENABLE_WCHAR_INPUT 0
+#   endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// PLOG_CHAR_IS_UTF8 specifies character encoding of `char` type. On *nix
+// systems it's set to UTF-8 while on Windows in can be ANSI or UTF-8. It
+// automatically detects `/utf-8` command line option in MSVC. Also it can
+// be set manually if required.
+// This option allows to support http://utf8everywhere.org approach.
+
+#ifndef PLOG_CHAR_IS_UTF8
+#   if defined(_WIN32) && !defined(_UTF8)
+#       define PLOG_CHAR_IS_UTF8 0
+#   else
+#       define PLOG_CHAR_IS_UTF8 1
+#   endif
+#endif
+
+#ifdef _WIN32
+#   if defined(PLOG_EXPORT)
+#       define PLOG_LINKAGE __declspec(dllexport)
+#   elif defined(PLOG_IMPORT)
+#       define PLOG_LINKAGE __declspec(dllimport)
+#   endif
+#   if defined(PLOG_GLOBAL)
+#       error "PLOG_GLOBAL isn't supported on Windows"
+#   endif
+#else
+#   if defined(PLOG_GLOBAL)
+#       define PLOG_LINKAGE __attribute__ ((visibility ("default")))
+#   elif defined(PLOG_LOCAL)
+#       define PLOG_LINKAGE __attribute__ ((visibility ("hidden")))
+#       define PLOG_LINKAGE_HIDDEN PLOG_LINKAGE
+#   endif
+#   if defined(PLOG_EXPORT) || defined(PLOG_IMPORT)
+#       error "PLOG_EXPORT/PLOG_IMPORT is supported only on Windows"
+#   endif
+#endif
+
+#ifndef PLOG_LINKAGE
+#   define PLOG_LINKAGE
+#endif
+
+#ifndef PLOG_LINKAGE_HIDDEN
+#   define PLOG_LINKAGE_HIDDEN
+#endif
+
+#ifdef _WIN32
+#   include <plog/WinApi.h>
+#   include <time.h>
+#   include <sys/timeb.h>
+#   include <io.h>
+#   include <share.h>
+#else
+#   include <unistd.h>
+#   include <sys/time.h>
+#   if defined(__linux__) || defined(__FreeBSD__)
+#       include <sys/syscall.h>
+#   elif defined(__rtems__)
+#       include <rtems.h>
+#   endif
+#   if defined(_POSIX_THREADS)
+#       include <pthread.h>
+#   endif
+#   if PLOG_ENABLE_WCHAR_INPUT
+#       include <iconv.h>
+#   endif
+#endif
+
+#ifdef __FREERTOS__ // There is no standard way to know if the code is compiled for FreeRTOS. We expect __FREERTOS__ macro to be defined in such case.
+#   include <FreeRTOS.h>
+#   include <semphr.h>
+#   include <task.h>
+#endif
+
+#if PLOG_CHAR_IS_UTF8
+#   define PLOG_NSTR(x)    x
+#else
+#   define _PLOG_NSTR(x)   L##x
+#   define PLOG_NSTR(x)    _PLOG_NSTR(x)
+#endif
+
+#ifdef _WIN32
+#   define PLOG_CDECL      __cdecl
+#else
+#   define PLOG_CDECL
+#endif
+
+#if __cplusplus >= 201103L || defined(_MSC_VER) && _MSC_VER >= 1700
+#   define PLOG_OVERRIDE override
+#else
+#   define PLOG_OVERRIDE
+#endif
+
+namespace plog
+{
+    namespace util
+    {
+#if PLOG_CHAR_IS_UTF8
+        typedef std::string nstring;
+        typedef std::ostringstream nostringstream;
+        typedef std::istringstream nistringstream;
+        typedef std::ostream nostream;
+        typedef char nchar;
+#else
+        typedef std::wstring nstring;
+        typedef std::wostringstream nostringstream;
+        typedef std::wistringstream nistringstream;
+        typedef std::wostream nostream;
+        typedef wchar_t nchar;
+#endif
+
+        inline void localtime_s(struct tm* t, const time_t* time)
+        {
+#if defined(_WIN32) && defined(__BORLANDC__)
+            ::localtime_s(time, t);
+#elif defined(_WIN32) && defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+            *t = *::localtime(time);
+#elif defined(_WIN32)
+            ::localtime_s(t, time);
+#else
+            ::localtime_r(time, t);
+#endif
+        }
+
+        inline void gmtime_s(struct tm* t, const time_t* time)
+        {
+#if defined(_WIN32) && defined(__BORLANDC__)
+            ::gmtime_s(time, t);
+#elif defined(_WIN32) && defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+            *t = *::gmtime(time);
+#elif defined(_WIN32)
+            ::gmtime_s(t, time);
+#else
+            ::gmtime_r(time, t);
+#endif
+        }
+
+#ifdef _WIN32
+        typedef timeb Time;
+
+        inline void ftime(Time* t)
+        {
+            ::ftime(t);
+        }
+#else
+        struct Time
+        {
+            time_t time;
+            unsigned short millitm;
+        };
+
+        inline void ftime(Time* t)
+        {
+            timeval tv;
+            ::gettimeofday(&tv, NULL);
+
+            t->time = tv.tv_sec;
+            t->millitm = static_cast<unsigned short>(tv.tv_usec / 1000);
+        }
+#endif
+
+        inline unsigned int gettid()
+        {
+#if defined(__FREERTOS__) && defined(INCLUDE_xTaskGetCurrentTaskHandle)
+            return static_cast<unsigned int>(reinterpret_cast<uintptr_t>(xTaskGetCurrentTaskHandle()));
+#elif defined(_WIN32)
+            return GetCurrentThreadId();
+#elif defined(__linux__)
+            return static_cast<unsigned int>(::syscall(__NR_gettid));
+#elif defined(__FreeBSD__)
+            long tid;
+            syscall(SYS_thr_self, &tid);
+            return static_cast<unsigned int>(tid);
+#elif defined(__rtems__)
+            return rtems_task_self();
+#elif defined(__APPLE__)
+            uint64_t tid64;
+            pthread_threadid_np(NULL, &tid64);
+            return static_cast<unsigned int>(tid64);
+#else
+            return 0;
+#endif
+        }
+
+#ifndef _GNU_SOURCE
+    inline int vasprintf(char** strp, const char* format, va_list ap)
+    {
+        va_list ap_copy;
+#if defined(_MSC_VER) && _MSC_VER <= 1600
+        ap_copy = ap; // there is no va_copy on Visual Studio 2010
+#else
+        va_copy(ap_copy, ap);
+#endif
+#ifndef __STDC_SECURE_LIB__
+        int charCount = vsnprintf(NULL, 0, format, ap_copy);
+#else
+        int charCount = _vscprintf(format, ap_copy);
+#endif
+        va_end(ap_copy);
+        if (charCount < 0)
+        {
+            return -1;
+        }
+
+        size_t bufferCharCount = static_cast<size_t>(charCount) + 1;
+
+        char* str = static_cast<char*>(malloc(bufferCharCount));
+        if (!str)
+        {
+            return -1;
+        }
+
+#ifndef __STDC_SECURE_LIB__
+        int retval = vsnprintf(str, bufferCharCount, format, ap);
+#else
+        int retval = vsnprintf_s(str, bufferCharCount, static_cast<size_t>(-1), format, ap);
+#endif
+        if (retval < 0)
+        {
+            free(str);
+            return -1;
+        }
+
+        *strp = str;
+        return retval;
+    }
+#endif
+
+#ifdef _WIN32
+    inline int vaswprintf(wchar_t** strp, const wchar_t* format, va_list ap)
+    {
+#if defined(__BORLANDC__)
+        int charCount = 0x1000; // there is no _vscwprintf on Borland/Embarcadero
+#else
+        int charCount = _vscwprintf(format, ap);
+        if (charCount < 0)
+        {
+            return -1;
+        }
+#endif
+
+        size_t bufferCharCount = static_cast<size_t>(charCount) + 1;
+
+        wchar_t* str = static_cast<wchar_t*>(malloc(bufferCharCount * sizeof(wchar_t)));
+        if (!str)
+        {
+            return -1;
+        }
+
+#if defined(__BORLANDC__)
+        int retval = vsnwprintf_s(str, bufferCharCount, format, ap);
+#elif defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+        int retval = _vsnwprintf(str, bufferCharCount, format, ap);
+#else
+        int retval = _vsnwprintf_s(str, bufferCharCount, charCount, format, ap);
+#endif
+        if (retval < 0)
+        {
+            free(str);
+            return -1;
+        }
+
+        *strp = str;
+        return retval;
+    }
+#endif
+
+#ifdef _WIN32
+        inline std::wstring toWide(const char* str, UINT cp = codePage::kChar)
+        {
+            size_t len = ::strlen(str);
+            std::wstring wstr(len, 0);
+
+            if (!wstr.empty())
+            {
+                int wlen = MultiByteToWideChar(cp, 0, str, static_cast<int>(len), &wstr[0], static_cast<int>(wstr.size()));
+                wstr.resize(wlen);
+            }
+
+            return wstr;
+        }
+
+        inline std::wstring toWide(const std::string& str, UINT cp = codePage::kChar)
+        {
+            return toWide(str.c_str(), cp);
+        }
+
+        inline const std::wstring& toWide(const std::wstring& str) // do nothing for already wide string
+        {
+            return str;
+        }
+
+        inline std::string toNarrow(const std::wstring& wstr, long page)
+        {
+            int len = WideCharToMultiByte(page, 0, wstr.c_str(), static_cast<int>(wstr.size()), 0, 0, 0, 0);
+            std::string str(len, 0);
+
+            if (!str.empty())
+            {
+                WideCharToMultiByte(page, 0, wstr.c_str(), static_cast<int>(wstr.size()), &str[0], len, 0, 0);
+            }
+
+            return str;
+        }
+#elif PLOG_ENABLE_WCHAR_INPUT
+        inline std::string toNarrow(const wchar_t* wstr)
+        {
+            size_t wlen = ::wcslen(wstr);
+            std::string str(wlen * sizeof(wchar_t), 0);
+
+            if (!str.empty())
+            {
+                const char* in = reinterpret_cast<const char*>(&wstr[0]);
+                char* out = &str[0];
+                size_t inBytes = wlen * sizeof(wchar_t);
+                size_t outBytes = str.size();
+
+                iconv_t cd = ::iconv_open("UTF-8", "WCHAR_T");
+                ::iconv(cd, const_cast<char**>(&in), &inBytes, &out, &outBytes);
+                ::iconv_close(cd);
+
+                str.resize(str.size() - outBytes);
+            }
+
+            return str;
+        }
+#endif
+
+        inline std::string processFuncName(const char* func)
+        {
+#if (defined(_WIN32) && !defined(__MINGW32__)) || defined(__OBJC__)
+            return std::string(func);
+#else
+            const char* funcBegin = func;
+            const char* funcEnd = ::strchr(funcBegin, '(');
+            int foundTemplate = 0;
+
+            if (!funcEnd)
+            {
+                return std::string(func);
+            }
+
+            for (const char* i = funcEnd - 1; i >= funcBegin; --i) // search backwards for the first space char
+            {
+                if (*i == '>')
+                {
+                    foundTemplate++;
+                }
+                else if (*i == '<')
+                {
+                    foundTemplate--;
+                }
+                else if (*i == ' ' && foundTemplate == 0)
+                {
+                    funcBegin = i + 1;
+                    break;
+                }
+            }
+
+            return std::string(funcBegin, funcEnd);
+#endif
+        }
+
+        inline const nchar* findExtensionDot(const nchar* fileName)
+        {
+#if PLOG_CHAR_IS_UTF8
+            return std::strrchr(fileName, '.');
+#else
+            return std::wcsrchr(fileName, L'.');
+#endif
+        }
+
+        inline void splitFileName(const nchar* fileName, nstring& fileNameNoExt, nstring& fileExt)
+        {
+            const nchar* dot = findExtensionDot(fileName);
+
+            if (dot)
+            {
+                fileNameNoExt.assign(fileName, dot);
+                fileExt.assign(dot + 1);
+            }
+            else
+            {
+                fileNameNoExt.assign(fileName);
+                fileExt.clear();
+            }
+        }
+
+        class PLOG_LINKAGE NonCopyable
+        {
+        protected:
+            NonCopyable()
+            {
+            }
+
+        private:
+            NonCopyable(const NonCopyable&);
+            NonCopyable& operator=(const NonCopyable&);
+        };
+
+        class PLOG_LINKAGE_HIDDEN File : NonCopyable
+        {
+        public:
+            File() : m_file(-1)
+            {
+            }
+
+            ~File()
+            {
+                close();
+            }
+
+            size_t open(const nstring& fileName)
+            {
+#if defined(_WIN32) && (defined(__BORLANDC__) || defined(__MINGW32__))
+                m_file = ::_wsopen(toWide(fileName).c_str(), _O_CREAT | _O_WRONLY | _O_BINARY | _O_NOINHERIT, SH_DENYWR, _S_IREAD | _S_IWRITE);
+#elif defined(_WIN32)
+                ::_wsopen_s(&m_file, toWide(fileName).c_str(), _O_CREAT | _O_WRONLY | _O_BINARY | _O_NOINHERIT, _SH_DENYWR, _S_IREAD | _S_IWRITE);
+#elif defined(O_CLOEXEC)
+                m_file = ::open(fileName.c_str(), O_CREAT | O_APPEND | O_WRONLY | O_CLOEXEC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+#else
+                m_file = ::open(fileName.c_str(), O_CREAT | O_APPEND | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+#endif
+                return seek(0, SEEK_END);
+            }
+
+            size_t write(const void* buf, size_t count)
+            {
+                return m_file != -1 ? static_cast<size_t>(
+#ifdef _WIN32
+                    ::_write(m_file, buf, static_cast<unsigned int>(count))
+#else
+                    ::write(m_file, buf, count)
+#endif
+                    ) : static_cast<size_t>(-1);
+            }
+
+            template<class CharType>
+            size_t write(const std::basic_string<CharType>& str)
+            {
+                return write(str.data(), str.size() * sizeof(CharType));
+            }
+
+            size_t seek(size_t offset, int whence)
+            {
+                return m_file != -1 ? static_cast<size_t>(
+#if defined(_WIN32) && (defined(__BORLANDC__) || defined(__MINGW32__))
+                    ::_lseek(m_file, static_cast<off_t>(offset), whence)
+#elif defined(_WIN32)
+                    ::_lseeki64(m_file, static_cast<off_t>(offset), whence)
+#else
+                    ::lseek(m_file, static_cast<off_t>(offset), whence)
+#endif
+                    ) : static_cast<size_t>(-1);
+            }
+
+            void close()
+            {
+                if (m_file != -1)
+                {
+#ifdef _WIN32
+                    ::_close(m_file);
+#else
+                    ::close(m_file);
+#endif
+                    m_file = -1;
+                }
+            }
+
+            static int unlink(const nstring& fileName)
+            {
+#ifdef _WIN32
+                return ::_wunlink(toWide(fileName).c_str());
+#else
+                return ::unlink(fileName.c_str());
+#endif
+            }
+
+            static int rename(const nstring& oldFilename, const nstring& newFilename)
+            {
+#ifdef _WIN32
+                return MoveFileW(toWide(oldFilename).c_str(), toWide(newFilename).c_str());
+#else
+                return ::rename(oldFilename.c_str(), newFilename.c_str());
+#endif
+            }
+
+        private:
+            int m_file;
+        };
+
+        class PLOG_LINKAGE_HIDDEN Mutex : NonCopyable
+        {
+        public:
+            Mutex()
+            {
+#ifdef __FREERTOS__
+                m_sync = xSemaphoreCreateBinary();
+                xSemaphoreGive(m_sync);
+#elif defined(_WIN32)
+                InitializeCriticalSection(&m_sync);
+#elif defined(__rtems__)
+                rtems_semaphore_create(0, 1,
+                            RTEMS_PRIORITY |
+                            RTEMS_BINARY_SEMAPHORE |
+                            RTEMS_INHERIT_PRIORITY, 1, &m_sync);
+#elif defined(_POSIX_THREADS)
+                ::pthread_mutex_init(&m_sync, 0);
+#endif
+            }
+
+            ~Mutex()
+            {
+#ifdef __FREERTOS__
+                vSemaphoreDelete(m_sync);
+#elif defined(_WIN32)
+                DeleteCriticalSection(&m_sync);
+#elif defined(__rtems__)
+                rtems_semaphore_delete(m_sync);
+#elif defined(_POSIX_THREADS)
+                ::pthread_mutex_destroy(&m_sync);
+#endif
+            }
+
+            friend class MutexLock;
+
+        private:
+            void lock()
+            {
+#ifdef __FREERTOS__
+                xSemaphoreTake(m_sync, portMAX_DELAY);
+#elif defined(_WIN32)
+                EnterCriticalSection(&m_sync);
+#elif defined(__rtems__)
+                rtems_semaphore_obtain(m_sync, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+#elif defined(_POSIX_THREADS)
+                ::pthread_mutex_lock(&m_sync);
+#endif
+            }
+
+            void unlock()
+            {
+#ifdef __FREERTOS__
+                xSemaphoreGive(m_sync);
+#elif defined(_WIN32)
+                LeaveCriticalSection(&m_sync);
+#elif defined(__rtems__)
+                rtems_semaphore_release(m_sync);
+#elif defined(_POSIX_THREADS)
+                ::pthread_mutex_unlock(&m_sync);
+#endif
+            }
+
+        private:
+#ifdef __FREERTOS__
+            SemaphoreHandle_t m_sync;
+#elif defined(_WIN32)
+            CRITICAL_SECTION m_sync;
+#elif defined(__rtems__)
+            rtems_id m_sync;
+#elif defined(_POSIX_THREADS)
+            pthread_mutex_t m_sync;
+#endif
+        };
+
+        class PLOG_LINKAGE_HIDDEN MutexLock : NonCopyable
+        {
+        public:
+            MutexLock(Mutex& mutex) : m_mutex(mutex)
+            {
+                m_mutex.lock();
+            }
+
+            ~MutexLock()
+            {
+                m_mutex.unlock();
+            }
+
+        private:
+            Mutex& m_mutex;
+        };
+
+        template<class T>
+#ifdef _WIN32
+        class Singleton : NonCopyable
+#else
+        class PLOG_LINKAGE Singleton : NonCopyable
+#endif
+        {
+        public:
+#if (defined(__clang__) || defined(__GNUC__) && __GNUC__ >= 8) && !defined(__BORLANDC__)
+            // This constructor is called before the `T` object is fully constructed, and
+            // pointers are not dereferenced anyway, so UBSan shouldn't check vptrs.
+            __attribute__((no_sanitize("vptr")))
+#endif
+            Singleton()
+            {
+                assert(!m_instance);
+                m_instance = static_cast<T*>(this);
+            }
+
+            ~Singleton()
+            {
+                assert(m_instance);
+                m_instance = 0;
+            }
+
+            static T* getInstance()
+            {
+                return m_instance;
+            }
+
+        private:
+            static T* m_instance;
+        };
+
+        template<class T>
+        T* Singleton<T>::m_instance = NULL;
+    }
+}
diff --git a/include/plog/WinApi.h b/include/plog/WinApi.h
new file mode 100644
index 000000000..ccf44af0a
--- /dev/null
+++ b/include/plog/WinApi.h
@@ -0,0 +1,175 @@
+#pragma once
+
+#ifdef _WIN32
+
+// These windows structs must be in a global namespace
+struct HKEY__;
+struct _SECURITY_ATTRIBUTES;
+struct _CONSOLE_SCREEN_BUFFER_INFO;
+struct _RTL_CRITICAL_SECTION;
+
+namespace plog
+{
+    typedef unsigned long DWORD;
+    typedef unsigned short WORD;
+    typedef unsigned char BYTE;
+    typedef unsigned int UINT;
+    typedef int BOOL;
+    typedef long LSTATUS;
+    typedef char* LPSTR;
+    typedef wchar_t* LPWSTR;
+    typedef const char* LPCSTR;
+    typedef const wchar_t* LPCWSTR;
+    typedef void* HANDLE;
+    typedef HKEY__* HKEY;
+    typedef size_t ULONG_PTR;
+
+    struct CRITICAL_SECTION
+    {
+        void* DebugInfo;
+        long LockCount;
+        long RecursionCount;
+        HANDLE OwningThread;
+        HANDLE LockSemaphore;
+        ULONG_PTR SpinCount;
+    };
+
+    struct COORD
+    {
+        short X;
+        short Y;
+    };
+
+    struct SMALL_RECT
+    {
+        short Left;
+        short Top;
+        short Right;
+        short Bottom;
+    };
+
+    struct CONSOLE_SCREEN_BUFFER_INFO
+    {
+        COORD dwSize;
+        COORD dwCursorPosition;
+        WORD  wAttributes;
+        SMALL_RECT srWindow;
+        COORD dwMaximumWindowSize;
+    };
+
+    namespace codePage
+    {
+        const UINT kActive = 0;
+        const UINT kUTF8 = 65001;
+#if PLOG_CHAR_IS_UTF8
+        const UINT kChar = kUTF8;
+#else
+        const UINT kChar = kActive;
+#endif
+    }
+
+    namespace eventLog
+    {
+        const WORD kErrorType = 0x0001;
+        const WORD kWarningType = 0x0002;
+        const WORD kInformationType = 0x0004;
+    }
+
+    namespace hkey
+    {
+        const HKEY kLocalMachine = reinterpret_cast<HKEY>(static_cast<ULONG_PTR>(0x80000002));
+    }
+
+    namespace regSam
+    {
+        const DWORD kQueryValue = 0x0001;
+        const DWORD kSetValue = 0x0002;
+    }
+
+    namespace regType
+    {
+        const DWORD kExpandSz = 2;
+        const DWORD kDword = 4;
+    }
+
+     namespace stdHandle
+    {
+        const DWORD kOutput = static_cast<DWORD>(-11);
+        const DWORD kErrorOutput = static_cast<DWORD>(-12);
+    }
+
+    namespace foreground
+    {
+        const WORD kBlue = 0x0001;
+        const WORD kGreen = 0x0002;
+        const WORD kRed = 0x0004;
+        const WORD kIntensity = 0x0008;
+    }
+
+    namespace background
+    {
+        const WORD kBlue = 0x0010;
+        const WORD kGreen = 0x0020;
+        const WORD kRed = 0x0040;
+        const WORD kIntensity = 0x0080;
+    }
+
+    extern "C"
+    {
+        __declspec(dllimport) int __stdcall MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
+        __declspec(dllimport) int __stdcall WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cbMultiByte, const char* lpDefaultChar, BOOL* lpUsedDefaultChar);
+
+        __declspec(dllimport) DWORD __stdcall GetCurrentThreadId();
+
+        __declspec(dllimport) BOOL __stdcall MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName);
+
+        __declspec(dllimport) void __stdcall InitializeCriticalSection(_RTL_CRITICAL_SECTION* lpCriticalSection);
+        __declspec(dllimport) void __stdcall EnterCriticalSection(_RTL_CRITICAL_SECTION* lpCriticalSection);
+        __declspec(dllimport) void __stdcall LeaveCriticalSection(_RTL_CRITICAL_SECTION* lpCriticalSection);
+        __declspec(dllimport) void __stdcall DeleteCriticalSection(_RTL_CRITICAL_SECTION* lpCriticalSection);
+
+        __declspec(dllimport) HANDLE __stdcall RegisterEventSourceW(LPCWSTR lpUNCServerName, LPCWSTR lpSourceName);
+        __declspec(dllimport) BOOL __stdcall DeregisterEventSource(HANDLE hEventLog);
+        __declspec(dllimport) BOOL __stdcall ReportEventW(HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, void* lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR* lpStrings, void* lpRawData);
+
+        __declspec(dllimport) LSTATUS __stdcall RegCreateKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD Reserved, LPWSTR lpClass, DWORD dwOptions, DWORD samDesired, _SECURITY_ATTRIBUTES* lpSecurityAttributes, HKEY* phkResult, DWORD* lpdwDisposition);
+        __declspec(dllimport) LSTATUS __stdcall RegSetValueExW(HKEY hKey, LPCWSTR lpValueName, DWORD Reserved, DWORD dwType, const BYTE* lpData, DWORD cbData);
+        __declspec(dllimport) LSTATUS __stdcall RegCloseKey(HKEY hKey);
+        __declspec(dllimport) LSTATUS __stdcall RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, DWORD samDesired, HKEY* phkResult);
+        __declspec(dllimport) LSTATUS __stdcall RegDeleteKeyW(HKEY hKey, LPCWSTR lpSubKey);
+
+        __declspec(dllimport) HANDLE __stdcall GetStdHandle(DWORD nStdHandle);
+
+        __declspec(dllimport) BOOL __stdcall WriteConsoleW(HANDLE hConsoleOutput, const void* lpBuffer, DWORD nNumberOfCharsToWrite, DWORD* lpNumberOfCharsWritten, void* lpReserved);
+        __declspec(dllimport) BOOL __stdcall GetConsoleScreenBufferInfo(HANDLE hConsoleOutput, _CONSOLE_SCREEN_BUFFER_INFO* lpConsoleScreenBufferInfo);
+        __declspec(dllimport) BOOL __stdcall SetConsoleTextAttribute(HANDLE hConsoleOutput, WORD wAttributes);
+
+        __declspec(dllimport) void __stdcall OutputDebugStringW(LPCWSTR lpOutputString);
+    }
+
+    inline void InitializeCriticalSection(CRITICAL_SECTION* criticalSection)
+    {
+        plog::InitializeCriticalSection(reinterpret_cast<_RTL_CRITICAL_SECTION*>(criticalSection));
+    }
+
+    inline void EnterCriticalSection(CRITICAL_SECTION* criticalSection)
+    {
+        plog::EnterCriticalSection(reinterpret_cast<_RTL_CRITICAL_SECTION*>(criticalSection));
+    }
+
+    inline void LeaveCriticalSection(CRITICAL_SECTION* criticalSection)
+    {
+        plog::LeaveCriticalSection(reinterpret_cast<_RTL_CRITICAL_SECTION*>(criticalSection));
+    }
+
+    inline void DeleteCriticalSection(CRITICAL_SECTION* criticalSection)
+    {
+        plog::DeleteCriticalSection(reinterpret_cast<_RTL_CRITICAL_SECTION*>(criticalSection));
+    }
+
+    inline BOOL GetConsoleScreenBufferInfo(HANDLE consoleOutput, CONSOLE_SCREEN_BUFFER_INFO* consoleScreenBufferInfo)
+    {
+        return plog::GetConsoleScreenBufferInfo(consoleOutput, reinterpret_cast<_CONSOLE_SCREEN_BUFFER_INFO*>(consoleScreenBufferInfo));
+    }
+}
+#endif // _WIN32
diff --git a/include/toml11/LICENSE b/include/toml11/LICENSE
new file mode 100644
index 000000000..f55c511d6
--- /dev/null
+++ b/include/toml11/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Toru Niina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/src/global/utils/toml.h b/include/toml11/toml.hpp
similarity index 100%
rename from src/global/utils/toml.h
rename to include/toml11/toml.hpp
diff --git a/input.example.toml b/input.example.toml
index bffb1d71a..3a5112495 100644
--- a/input.example.toml
+++ b/input.example.toml
@@ -195,6 +195,83 @@
   #     @from: `scales.larmor0`
   #     @value: `1 / larmor0`
 
+[radiation]
+  [radiation.drag]
+    [radiation.drag.synchrotron]
+      # Radiation reaction limit gamma-factor for synchrotron
+      #   @type: float [> 0.0]
+      #   @default: 1.0
+      #   @note: [required] if one of the species has `radiative_drag = "synchrotron"`
+      gamma_rad = ""
+
+    [radiation.drag.compton]
+      # Radiation reaction limit gamma-factor for Compton drag
+      #   @type: float [> 0.0]
+      #   @default: 1.0
+      #   @note: [required] if one of the species has `radiative_drag = "compton"`
+      gamma_rad = ""
+
+  [radiation.emission]
+    [radiation.emission.synchrotron]
+      # Gamma-factor of a particle emitting synchrotron photons at energy `m0 c^2` in fiducial magnetic field `B0`
+      #   @type: float [> 1.0]
+      #   @default: 10.0
+      gamma_qed = ""
+      # Minimum photon energy for synchrotron emission (units of `m0 c^2`)
+      #   @type: float [> 0.0]
+      #   @default: 1e-4
+      photon_energy_min = ""
+      # Weights for the emitted synchrotron photons
+      #   @type: float [> 0.0]
+      #   @default: 1.0
+      photon_weight = ""
+      # Index of species for the emitted photon
+      #   @type: ushort [> 0]
+      #   @required
+      photon_species = ""
+
+      # @inferred:
+      # - nominal_probability
+      #     @brief: Nominal probability of the emission for a particle with `gamma * beta = 1`, charge-to-mass = `q0 / m0`
+      #     @type: float
+      #     @from: `.gamma_qed`, `.photon_weight`, `...drag.synchrotron.gamma_rad`, `scales.omegaB0`, `algorithms.timestep.dt`
+      #     @value: `0.1 * omegaB0 * dt * (gamma_qed / gamma_rad)^2 / photon_weight`
+      # - nominal_photon_energy
+      #     @brief: Nominal energy of the emitted photon for a particle with `gamma * beta = 1`, mass = `m0`
+      #     @type: float
+      #     @from: `.gamma_qed`
+      #     @value: `(1 / gamma_qed)^2`
+
+    [radiation.emission.compton]
+      # Gamma-factor of a particle emitting inverse Compton photons at energy `m0 c^2` in fiducial magnetic field `B0`
+      #   @type: float [> 1.0]
+      #   @default: 10.0
+      gamma_qed = ""
+      # Minimum photon energy for inverse Compton emission (units of `m0 c^2`)
+      #   @type: float [> 0.0]
+      #   @default: 1e-4
+      photon_energy_min = ""
+      # Weights for the emitted inverse Compton photons
+      #   @type: float [> 0.0]
+      #   @default: 1.0
+      photon_weight = ""
+      # Index of species for the emitted photon
+      #   @type: ushort [> 0]
+      #   @required
+      photon_species = ""
+
+      # @inferred:
+      # - nominal_probability
+      #     @brief: Nominal probability of the emission for a particle with `gamma * beta = 1`, charge-to-mass = `q0 / m0`
+      #     @type: float
+      #     @from: `.gamma_qed`, `.photon_weight`, `...drag.compton.gamma_rad`, `scales.omegaB0`, `algorithms.timestep.dt`
+      #     @value: `0.1 * omegaB0 * dt * (gamma_qed / gamma_rad)^2 / photon_weight`
+      # - nominal_photon_energy
+      #     @brief: Nominal energy of the emitted photon for a particle with `gamma * beta = 1`, mass = `m0`
+      #     @type: float
+      #     @from: `.gamma_qed`
+      #     @value: `(1 / gamma_qed)^2`
+
 [algorithms]
   # Number of current smoothing passes
   #   @type: ushort [>= 0]
@@ -224,10 +301,12 @@
     #   @type: bool
     #   @default: true
     enable = ""
-    # Order of the particle shape function
-    #   @type: int
-    #   @default: 1
-    order = ""
+
+    # @inferred:
+    # - order
+    #     @brief: order of the particle shape function
+    #     @from: compile-time definition `shape_order`
+    #     @type: ushort [0 -> 10]
 
   [algorithms.gr]
     # Stepsize for numerical differentiation in GR pusher
@@ -250,13 +329,6 @@
     #   @note: When `larmor_max` == 0, the limit is disabled
     larmor_max = ""
 
-  [algorithms.synchrotron]
-    # Radiation reaction limit gamma-factor for synchrotron
-    #   @type: float [> 0.0]
-    #   @default: 1.0
-    #   @note: [required] if one of the species has `cooling = "synchrotron"`
-    gamma_rad = ""
-
   # Stencil coefficients for the field solver [notation as in Blinne+ (2018)]
   #   @note: Standard Yee solver: `delta_i = beta_ij = 0.0`
   [algorithms.fieldsolver]
@@ -370,8 +442,17 @@
     # Radiation reaction to use for the species
     #   @type: string
     #   @default: "None"
-    #   @enum: "None", "Synchrotron"
-    cooling = ""
+    #   @enum: "None", "Synchrotron", "Compton"
+    #   @note: Can also be coma-separated combination, e.g., "Synchrotron,Compton"
+    #   @note: Relevant radiation.drag parameters should also be provided
+    radiative_drag = ""
+    # Particle emission policy for the species
+    #   @type: string
+    #   @default: "None"
+    #   @enum: "None", "Synchrotron", "Compton"
+    #   @note: Only one emission mechanism allowed
+    #   @note: Appropriate radiation drag flag will be applied automatically (unless explicitly set to "None")
+    emission = ""
 
 # Parameters for specific problem generators and setups
 [setup]
diff --git a/minimal/CMakeLists.txt b/minimal/CMakeLists.txt
index b21dd0fec..c77775223 100644
--- a/minimal/CMakeLists.txt
+++ b/minimal/CMakeLists.txt
@@ -83,13 +83,16 @@ if("KOKKOS" IN_LIST MODES)
 endif()
 
 if("ADIOS2_NOMPI" IN_LIST MODES)
-  set(libs stdc++fs)
+  set(libs "")
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+    list(APPEND libs stdc++fs)
+  endif()
   set(exec adios2-nompi.xc)
   set(src ${CMAKE_CURRENT_SOURCE_DIR}/adios2.cpp)
 
   find_kokkos()
   find_adios2()
-  list(APPEND libs Kokkos::kokkos adios2::cxx11)
+  list(APPEND libs Kokkos::kokkos adios2::cxx)
 
   add_executable(${exec} ${src})
 
@@ -97,14 +100,17 @@ if("ADIOS2_NOMPI" IN_LIST MODES)
 endif()
 
 if("ADIOS2_MPI" IN_LIST MODES)
-  set(libs stdc++fs)
+  set(libs "")
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+    list(APPEND libs stdc++fs)
+  endif()
   set(exec adios2-mpi.xc)
   set(src ${CMAKE_CURRENT_SOURCE_DIR}/adios2.cpp)
 
   find_package(MPI REQUIRED)
   find_kokkos()
   find_adios2()
-  list(APPEND libs MPI::MPI_CXX Kokkos::kokkos adios2::cxx11_mpi)
+  list(APPEND libs MPI::MPI_CXX Kokkos::kokkos adios2::cxx_mpi)
 
   add_executable(${exec} ${src})
 
diff --git a/minimal/adios2.cpp b/minimal/adios2.cpp
index cd4ca3d6f..c89bf383b 100644
--- a/minimal/adios2.cpp
+++ b/minimal/adios2.cpp
@@ -1,6 +1,6 @@
 #include <Kokkos_Core.hpp>
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 
 #if defined(MPI_ENABLED)
   #include <mpi.h>
diff --git a/pgens/accretion/pgen.hpp b/pgens/accretion/pgen.hpp
index 42690f041..d79408588 100644
--- a/pgens/accretion/pgen.hpp
+++ b/pgens/accretion/pgen.hpp
@@ -5,13 +5,13 @@
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
 #include "utils/numeric.h"
 
 #include "archetypes/energy_dist.h"
 #include "archetypes/particle_injector.h"
 #include "archetypes/problem_generator.h"
 #include "archetypes/spatial_dist.h"
+#include "archetypes/traits.h"
 #include "framework/domain/metadomain.h"
 
 #include "kernels/particle_moments.hpp"
@@ -43,7 +43,8 @@ namespace user {
                      TWO * metric.spin() * g_00);
     }
 
-    Inline auto bx1(const coord_t<D>& x_Ph) const -> real_t { // at ( i , j + HALF )
+    Inline auto bx1(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i , j + HALF )
       coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
       metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
 
@@ -61,7 +62,8 @@ namespace user {
       }
     }
 
-    Inline auto bx2(const coord_t<D>& x_Ph) const -> real_t { // at ( i + HALF , j )
+    Inline auto bx2(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i + HALF , j )
       coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
       metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
 
@@ -197,11 +199,17 @@ namespace user {
   template <SimEngine::type S, class M>
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
-    static constexpr auto engines { traits::compatible_with<SimEngine::GRPIC>::value };
+    static constexpr auto engines {
+      arch::traits::pgen::compatible_with<SimEngine::GRPIC>::value
+    };
     static constexpr auto metrics {
-      traits::compatible_with<Metric::Kerr_Schild, Metric::QKerr_Schild, Metric::Kerr_Schild_0>::value
+      arch::traits::pgen::compatible_with<Metric::Kerr_Schild,
+                                          Metric::QKerr_Schild,
+                                          Metric::Kerr_Schild_0>::value
+    };
+    static constexpr auto dimensions {
+      arch::traits::pgen::compatible_with<Dim::_2D>::value
     };
-    static constexpr auto dimensions { traits::compatible_with<Dim::_2D>::value };
 
     // for easy access to variables in the child class
     using arch::ProblemGenerator<S, M>::D;
diff --git a/pgens/magnetosphere/pgen.hpp b/pgens/magnetosphere/pgen.hpp
index 1afc8ccc4..706c35018 100644
--- a/pgens/magnetosphere/pgen.hpp
+++ b/pgens/magnetosphere/pgen.hpp
@@ -5,10 +5,10 @@
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
 #include "utils/numeric.h"
 
 #include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
 #include "framework/domain/metadomain.h"
 
 #include <string>
@@ -52,13 +52,13 @@ namespace user {
 
   template <Dimension D>
   struct DriveFields : public InitFields<D> {
-    DriveFields(real_t             time,
+    DriveFields(simtime_t          time,
                 real_t             bsurf,
                 real_t             rstar,
                 real_t             omega,
                 const std::string& field_geometry)
       : InitFields<D> { bsurf, rstar, field_geometry }
-      , time { time }
+      , time { (real_t)time }
       , Omega { omega } {}
 
     using InitFields<D>::bx1;
@@ -87,11 +87,15 @@ namespace user {
   template <SimEngine::type S, class M>
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
-    static constexpr auto engines { traits::compatible_with<SimEngine::SRPIC>::value };
+    static constexpr auto engines {
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC>::value
+    };
     static constexpr auto metrics {
-      traits::compatible_with<Metric::Spherical, Metric::QSpherical>::value
+      arch::traits::pgen::compatible_with<Metric::Spherical, Metric::QSpherical>::value
+    };
+    static constexpr auto dimensions {
+      arch::traits::pgen::compatible_with<Dim::_2D>::value
     };
-    static constexpr auto dimensions { traits::compatible_with<Dim::_2D>::value };
 
     // for easy access to variables in the child class
     using arch::ProblemGenerator<S, M>::D;
@@ -113,11 +117,11 @@ namespace user {
 
     inline PGen() {}
 
-    auto AtmFields(real_t time) const -> DriveFields<D> {
+    auto AtmFields(simtime_t time) const -> DriveFields<D> {
       return DriveFields<D> { time, Bsurf, Rstar, Omega, field_geom };
     }
 
-    auto MatchFields(real_t) const -> InitFields<D> {
+    auto MatchFields(simtime_t) const -> InitFields<D> {
       return InitFields<D> { Bsurf, Rstar, field_geom };
     }
   };
diff --git a/pgens/pgen.hpp b/pgens/pgen.hpp
index 78d8e6486..d2d091ebf 100644
--- a/pgens/pgen.hpp
+++ b/pgens/pgen.hpp
@@ -4,10 +4,10 @@
 #include "enums.h"
 #include "global.h"
 
-#include "arch/traits.h"
 #include "utils/formatting.h"
 
 #include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
 #include "framework/domain/metadomain.h"
 
 #include <plog/Log.h>
@@ -19,18 +19,18 @@ namespace user {
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
     static constexpr auto engines {
-      traits::compatible_with<SimEngine::SRPIC, SimEngine::GRPIC>::value
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC, SimEngine::GRPIC>::value
     };
     static constexpr auto metrics {
-      traits::compatible_with<Metric::Minkowski,
-                              Metric::Spherical,
-                              Metric::QSpherical,
-                              Metric::Kerr_Schild,
-                              Metric::QKerr_Schild,
-                              Metric::Kerr_Schild_0>::value
+      arch::traits::pgen::compatible_with<Metric::Minkowski,
+                                          Metric::Spherical,
+                                          Metric::QSpherical,
+                                          Metric::Kerr_Schild,
+                                          Metric::QKerr_Schild,
+                                          Metric::Kerr_Schild_0>::value
     };
     static constexpr auto dimensions {
-      traits::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value
+      arch::traits::pgen::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value
     };
 
     // for easy access to variables in the child class
diff --git a/pgens/reconnection/pgen.hpp b/pgens/reconnection/pgen.hpp
index d152b578a..bc6f7c75e 100644
--- a/pgens/reconnection/pgen.hpp
+++ b/pgens/reconnection/pgen.hpp
@@ -5,13 +5,13 @@
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
 #include "utils/numeric.h"
 
 #include "archetypes/energy_dist.h"
 #include "archetypes/particle_injector.h"
 #include "archetypes/problem_generator.h"
 #include "archetypes/spatial_dist.h"
+#include "archetypes/traits.h"
 #include "archetypes/utils.h"
 #include "framework/domain/metadomain.h"
 
@@ -141,10 +141,14 @@ namespace user {
   template <SimEngine::type S, class M>
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
-    static constexpr auto engines { traits::compatible_with<SimEngine::SRPIC>::value };
-    static constexpr auto metrics { traits::compatible_with<Metric::Minkowski>::value };
+    static constexpr auto engines {
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC>::value
+    };
+    static constexpr auto metrics {
+      arch::traits::pgen::compatible_with<Metric::Minkowski>::value
+    };
     static constexpr auto dimensions {
-      traits::compatible_with<Dim::_2D, Dim::_3D>::value
+      arch::traits::pgen::compatible_with<Dim::_2D, Dim::_3D>::value
     };
 
     // for easy access to variables in the child class
diff --git a/pgens/shock/pgen.hpp b/pgens/shock/pgen.hpp
index fc579777d..b8289c9a3 100644
--- a/pgens/shock/pgen.hpp
+++ b/pgens/shock/pgen.hpp
@@ -4,12 +4,12 @@
 #include "enums.h"
 #include "global.h"
 
-#include "arch/traits.h"
 #include "utils/error.h"
 #include "utils/numeric.h"
 
 #include "archetypes/field_setter.h"
 #include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
 #include "archetypes/utils.h"
 #include "framework/domain/metadomain.h"
 
@@ -69,10 +69,14 @@ namespace user {
   template <SimEngine::type S, class M>
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
-    static constexpr auto engines { traits::compatible_with<SimEngine::SRPIC>::value };
-    static constexpr auto metrics { traits::compatible_with<Metric::Minkowski>::value };
+    static constexpr auto engines {
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC>::value
+    };
+    static constexpr auto metrics {
+      arch::traits::pgen::compatible_with<Metric::Minkowski>::value
+    };
     static constexpr auto dimensions {
-      traits::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value
+      arch::traits::pgen::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value
     };
 
     // for easy access to variables in the child class
@@ -113,12 +117,12 @@ namespace user {
 
     inline PGen() {}
 
-    auto MatchFields(real_t time) const -> InitFields<D> {
+    auto MatchFields(simtime_t) const -> InitFields<D> {
       return init_flds;
     }
 
-    auto FixFieldsConst(const bc_in&,
-                        const em& comp) const -> std::pair<real_t, bool> {
+    auto FixFieldsConst(const bc_in&, const em& comp) const
+      -> std::pair<real_t, bool> {
       if (comp == em::ex1) {
         return { init_flds.ex1({ ZERO }), true };
       } else if (comp == em::ex2) {
diff --git a/pgens/streaming/pgen.hpp b/pgens/streaming/pgen.hpp
index dca6cc31d..9c87d7d97 100644
--- a/pgens/streaming/pgen.hpp
+++ b/pgens/streaming/pgen.hpp
@@ -5,11 +5,11 @@
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
 #include "utils/error.h"
 #include "utils/numeric.h"
 
 #include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
 #include "archetypes/utils.h"
 #include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
@@ -54,18 +54,20 @@ namespace user {
   struct PGen : public arch::ProblemGenerator<S, M> {
 
     // compatibility traits for the problem generator
-    static constexpr auto engines = traits::compatible_with<SimEngine::SRPIC>::value;
-    static constexpr auto metrics = traits::compatible_with<Metric::Minkowski>::value;
+    static constexpr auto engines =
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC>::value;
+    static constexpr auto metrics =
+      arch::traits::pgen::compatible_with<Metric::Minkowski>::value;
     static constexpr auto dimensions =
-      traits::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value;
+      arch::traits::pgen::compatible_with<Dim::_1D, Dim::_2D, Dim::_3D>::value;
 
     // for easy access to variables in the child class
     using arch::ProblemGenerator<S, M>::D;
     using arch::ProblemGenerator<S, M>::C;
     using arch::ProblemGenerator<S, M>::params;
 
-    prmvec_t drifts_in_x, drifts_in_y, drifts_in_z;
-    prmvec_t densities, temperatures;
+    prmvec_t      drifts_in_x, drifts_in_y, drifts_in_z;
+    prmvec_t      densities, temperatures;
     // initial magnetic field
     real_t        Btheta, Bphi, Bmag;
     InitFields<D> init_flds;
diff --git a/pgens/turbulence/pgen.hpp b/pgens/turbulence/pgen.hpp
index dce59f029..17093d86a 100644
--- a/pgens/turbulence/pgen.hpp
+++ b/pgens/turbulence/pgen.hpp
@@ -9,8 +9,8 @@
 #include "utils/numeric.h"
 
 #include "archetypes/energy_dist.h"
-#include "archetypes/particle_injector.h"
 #include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
 #include "archetypes/utils.h"
 #include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
@@ -293,9 +293,12 @@ namespace user {
   struct PGen : public arch::ProblemGenerator<S, M> {
 
     // compatibility traits for the problem generator
-    static constexpr auto engines = traits::compatible_with<SimEngine::SRPIC>::value;
-    static constexpr auto metrics = traits::compatible_with<Metric::Minkowski>::value;
-    static constexpr auto dimensions = traits::compatible_with<Dim::_2D, Dim::_3D>::value;
+    static constexpr auto engines =
+      arch::traits::pgen::compatible_with<SimEngine::SRPIC>::value;
+    static constexpr auto metrics =
+      arch::traits::pgen::compatible_with<Metric::Minkowski>::value;
+    static constexpr auto dimensions =
+      arch::traits::pgen::compatible_with<Dim::_2D, Dim::_3D>::value;
 
     // for easy access to variables in the child class
     using arch::ProblemGenerator<S, M>::D;
diff --git a/pgens/wald/pgen.hpp b/pgens/wald/pgen.hpp
index 71ee905e3..292f6f7fe 100644
--- a/pgens/wald/pgen.hpp
+++ b/pgens/wald/pgen.hpp
@@ -5,21 +5,16 @@
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
 #include "utils/comparators.h"
 #include "utils/error.h"
 #include "utils/formatting.h"
-#include "utils/log.h"
 #include "utils/numeric.h"
 
-#include "archetypes/energy_dist.h"
-#include "archetypes/particle_injector.h"
 #include "archetypes/problem_generator.h"
-#include "framework/domain/domain.h"
+#include "archetypes/traits.h"
 #include "framework/domain/metadomain.h"
 
 #include <string>
-#include <vector>
 
 enum InitFieldGeometry {
   Wald,
@@ -64,7 +59,8 @@ namespace user {
                      TWO * metric.spin() * g_00);
     }
 
-    Inline auto bx1(const coord_t<D>& x_Ph) const -> real_t { // at ( i , j + HALF )
+    Inline auto bx1(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i , j + HALF )
       coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
       metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
 
@@ -82,7 +78,8 @@ namespace user {
       }
     }
 
-    Inline auto bx2(const coord_t<D>& x_Ph) const -> real_t { // at ( i + HALF , j )
+    Inline auto bx2(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i + HALF , j )
       coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
       metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
 
@@ -99,8 +96,8 @@ namespace user {
       }
     }
 
-    Inline auto bx3(
-      const coord_t<D>& x_Ph) const -> real_t { // at ( i + HALF , j + HALF )
+    Inline auto bx3(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i + HALF , j + HALF )
       if (field_geometry == InitFieldGeometry::Wald) {
         coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
         metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
@@ -120,7 +117,8 @@ namespace user {
       }
     }
 
-    Inline auto dx1(const coord_t<D>& x_Ph) const -> real_t { // at ( i + HALF , j )
+    Inline auto dx1(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i + HALF , j )
       if (field_geometry == InitFieldGeometry::Wald) {
         coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
         metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
@@ -158,7 +156,8 @@ namespace user {
       }
     }
 
-    Inline auto dx2(const coord_t<D>& x_Ph) const -> real_t { // at ( i , j + HALF )
+    Inline auto dx2(const coord_t<D>& x_Ph) const
+      -> real_t { // at ( i , j + HALF )
       if (field_geometry == InitFieldGeometry::Wald) {
         coord_t<D> xi { ZERO }, x0m { ZERO }, x0p { ZERO };
         metric.template convert<Crd::Ph, Crd::Cd>(x_Ph, xi);
@@ -232,11 +231,17 @@ namespace user {
   template <SimEngine::type S, class M>
   struct PGen : public arch::ProblemGenerator<S, M> {
     // compatibility traits for the problem generator
-    static constexpr auto engines { traits::compatible_with<SimEngine::GRPIC>::value };
+    static constexpr auto engines {
+      arch::traits::pgen::compatible_with<SimEngine::GRPIC>::value
+    };
     static constexpr auto metrics {
-      traits::compatible_with<Metric::Kerr_Schild, Metric::QKerr_Schild, Metric::Kerr_Schild_0>::value
+      arch::traits::pgen::compatible_with<Metric::Kerr_Schild,
+                                          Metric::QKerr_Schild,
+                                          Metric::Kerr_Schild_0>::value
+    };
+    static constexpr auto dimensions {
+      arch::traits::pgen::compatible_with<Dim::_2D>::value
     };
-    static constexpr auto dimensions { traits::compatible_with<Dim::_2D>::value };
 
     // for easy access to variables in the child class
     using arch::ProblemGenerator<S, M>::D;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 31114c330..443dc0545 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -24,15 +24,6 @@
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
-# dependencies
-add_subdirectory(${SRC_DIR}/global ${CMAKE_CURRENT_BINARY_DIR}/global)
-add_subdirectory(${SRC_DIR}/metrics ${CMAKE_CURRENT_BINARY_DIR}/metrics)
-add_subdirectory(${SRC_DIR}/kernels ${CMAKE_CURRENT_BINARY_DIR}/kernels)
-add_subdirectory(${SRC_DIR}/archetypes ${CMAKE_CURRENT_BINARY_DIR}/archetypes)
-add_subdirectory(${SRC_DIR}/framework ${CMAKE_CURRENT_BINARY_DIR}/framework)
-add_subdirectory(${SRC_DIR}/engines ${CMAKE_CURRENT_BINARY_DIR}/engines)
-add_subdirectory(${SRC_DIR}/output ${CMAKE_CURRENT_BINARY_DIR}/output)
-
 set(ENTITY ${PROJECT_NAME}.xc)
 set(SOURCES ${SRC_DIR}/entity.cpp)
 
diff --git a/src/archetypes/energy_dist.h b/src/archetypes/energy_dist.h
index 56a797751..230e4a932 100644
--- a/src/archetypes/energy_dist.h
+++ b/src/archetypes/energy_dist.h
@@ -26,6 +26,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include <Kokkos_Core.hpp>
 #include <Kokkos_Random.hpp>
 
@@ -33,10 +35,9 @@ namespace arch {
   using namespace ntt;
 
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M>
   struct EnergyDistribution {
     static constexpr auto D = M::Dim;
-    static constexpr bool is_energy_dist { true };
-    static_assert(M::is_metric, "M must be a metric class");
 
     EnergyDistribution(const M& metric) : metric { metric } {}
 
diff --git a/src/archetypes/field_setter.h b/src/archetypes/field_setter.h
index 5c5c4dbe4..d4fab7a3b 100644
--- a/src/archetypes/field_setter.h
+++ b/src/archetypes/field_setter.h
@@ -27,33 +27,34 @@
 #include "arch/traits.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include <Kokkos_Core.hpp>
 
 namespace arch {
   using namespace ntt;
 
   template <class I, SimEngine::type S, class M>
+    requires metric::traits::HasD<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasConvert<M> &&
+               metric::traits::HasTransform_i<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasConvert_i<M>)) &&
+             (S == SimEngine::SRPIC &&
+                (::traits::fieldsetter::HasEx1<I, M::Dim> ||
+                 ::traits::fieldsetter::HasEx2<I, M::Dim> ||
+                 ::traits::fieldsetter::HasEx3<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx1<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx2<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx3<I, M::Dim>) ||
+              (S == SimEngine::GRPIC &&
+                 (::traits::fieldsetter::HasDx1<I, M::Dim> &&
+                  ::traits::fieldsetter::HasDx2<I, M::Dim> &&
+                  ::traits::fieldsetter::HasDx3<I, M::Dim>) ||
+               (::traits::fieldsetter::HasBx1<I, M::Dim> &&
+                ::traits::fieldsetter::HasBx2<I, M::Dim> &&
+                ::traits::fieldsetter::HasBx3<I, M::Dim>)))
   class SetEMFields_kernel {
     static constexpr Dimension D = M::Dim;
-    static constexpr bool defines_ex1 = traits::has_method<traits::ex1_t, I>::value;
-    static constexpr bool defines_ex2 = traits::has_method<traits::ex2_t, I>::value;
-    static constexpr bool defines_ex3 = traits::has_method<traits::ex3_t, I>::value;
-    static constexpr bool defines_bx1 = traits::has_method<traits::bx1_t, I>::value;
-    static constexpr bool defines_bx2 = traits::has_method<traits::bx2_t, I>::value;
-    static constexpr bool defines_bx3 = traits::has_method<traits::bx3_t, I>::value;
-    static constexpr bool defines_dx1 = traits::has_method<traits::dx1_t, I>::value;
-    static constexpr bool defines_dx2 = traits::has_method<traits::dx2_t, I>::value;
-    static constexpr bool defines_dx3 = traits::has_method<traits::dx3_t, I>::value;
-
-    static_assert(defines_ex1 || defines_ex2 || defines_ex3 || defines_bx1 ||
-                    defines_bx2 || defines_bx3 || defines_dx1 || defines_dx2 ||
-                    defines_dx3,
-                  "No field initializer defined");
-    static_assert((S != SimEngine::GRPIC) ||
-                    (defines_dx1 == defines_dx2 && defines_dx2 == defines_dx3 &&
-                     defines_bx1 == defines_bx2 && defines_bx2 == defines_bx3),
-                  "In GR mode, all components must be defined or none");
-    static_assert(M::is_metric, "M must be a metric class");
 
     ndfield_t<M::Dim, 6> EM;
     const I              finit;
@@ -72,37 +73,37 @@ namespace arch {
         const auto        i1_ = COORD(i1);
         coord_t<Dim::_1D> x_Phys { ZERO };
         if constexpr (S == SimEngine::SRPIC) {
-          if constexpr (defines_ex1) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF }, x_Phys);
             EM(i1, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF },
               finit.ex1(x_Phys));
           }
-          if constexpr (defines_ex2) {
+          if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ }, x_Phys);
             EM(i1, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ },
               finit.ex2(x_Phys));
           }
-          if constexpr (defines_ex3) {
+          if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ }, x_Phys);
             EM(i1, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ },
               finit.ex3(x_Phys));
           }
-          if constexpr (defines_bx1) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ }, x_Phys);
             EM(i1, em::bx1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ },
               finit.bx1(x_Phys));
           }
-          if constexpr (defines_bx2) {
+          if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF }, x_Phys);
             EM(i1, em::bx2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ + HALF },
               finit.bx2(x_Phys));
           }
-          if constexpr (defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_1D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF }, x_Phys);
             EM(i1, em::bx3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ + HALF },
@@ -123,37 +124,37 @@ namespace arch {
         // srpic
         if constexpr (S == SimEngine::SRPIC) {
           coord_t<Dim::_2D> x_Phys { ZERO };
-          if constexpr (defines_ex1) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ }, x_Phys);
             EM(i1, i2, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ },
               finit.ex1(x_Phys));
           }
-          if constexpr (defines_ex2) {
+          if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ + HALF }, x_Phys);
             EM(i1, i2, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_, i2_ + HALF },
               finit.ex2(x_Phys));
           }
-          if constexpr (defines_ex3) {
+          if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ }, x_Phys);
             EM(i1, i2, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_, i2_ },
               finit.ex3(x_Phys));
           }
-          if constexpr (defines_bx1) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ + HALF }, x_Phys);
             EM(i1, i2, em::bx1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_, i2_ + HALF },
               finit.bx1(x_Phys));
           }
-          if constexpr (defines_bx2) {
+          if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ }, x_Phys);
             EM(i1, i2, em::bx2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ },
               finit.bx2(x_Phys));
           }
-          if constexpr (defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_2D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ + HALF },
                                                       x_Phys);
             EM(i1, i2, em::bx3) = metric.template transform<3, Idx::T, Idx::U>(
@@ -162,7 +163,9 @@ namespace arch {
           }
         } else if constexpr (S == SimEngine::GRPIC) {
           // grpic
-          if constexpr (defines_dx1 && defines_dx2 && defines_dx3) {
+          if constexpr (::traits::fieldsetter::HasDx1<I, Dim::_2D> &&
+                        ::traits::fieldsetter::HasDx2<I, Dim::_2D> &&
+                        ::traits::fieldsetter::HasDx3<I, Dim::_2D>) {
             const real_t x1_0 { metric.template convert<1, Crd::Cd, Crd::Ph>(i1_) };
             const real_t x1_H { metric.template convert<1, Crd::Cd, Crd::Ph>(
               i1_ + HALF) };
@@ -179,7 +182,9 @@ namespace arch {
               EM(i1, i2, em::dx3) = finit.dx3({ x1_0, x2_0 });
             }
           }
-          if constexpr (defines_bx1 && defines_bx2 && defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_2D> &&
+                        ::traits::fieldsetter::HasBx2<I, Dim::_2D> &&
+                        ::traits::fieldsetter::HasBx3<I, Dim::_2D>) {
             const real_t x1_0 { metric.template convert<1, Crd::Cd, Crd::Ph>(i1_) };
             const real_t x1_H { metric.template convert<1, Crd::Cd, Crd::Ph>(
               i1_ + HALF) };
@@ -212,28 +217,28 @@ namespace arch {
         coord_t<Dim::_3D> x_Phys { ZERO };
         if constexpr (S == SimEngine::SRPIC) {
           // srpic
-          if constexpr (defines_ex1) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_, i3_ },
                                                       x_Phys);
             EM(i1, i2, i3, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF, i2_, i3_ },
               finit.ex1(x_Phys));
           }
-          if constexpr (defines_ex2) {
+          if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ + HALF, i3_ },
                                                       x_Phys);
             EM(i1, i2, i3, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_, i2_ + HALF, i3_ },
               finit.ex2(x_Phys));
           }
-          if constexpr (defines_ex3) {
+          if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_, i3_ + HALF },
                                                       x_Phys);
             EM(i1, i2, i3, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_, i2_, i3_ + HALF },
               finit.ex3(x_Phys));
           }
-          if constexpr (defines_bx1) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>(
               { i1_, i2_ + HALF, i3_ + HALF },
               x_Phys);
@@ -241,7 +246,7 @@ namespace arch {
               { i1_, i2_ + HALF, i3_ + HALF },
               finit.bx1(x_Phys));
           }
-          if constexpr (defines_bx2) {
+          if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>(
               { i1_ + HALF, i2_, i3_ + HALF },
               x_Phys);
@@ -249,7 +254,7 @@ namespace arch {
               { i1_ + HALF, i2_, i3_ + HALF },
               finit.bx2(x_Phys));
           }
-          if constexpr (defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_3D>) {
             metric.template convert<Crd::Cd, Crd::Ph>(
               { i1_ + HALF, i2_ + HALF, i3_ },
               x_Phys);
@@ -269,71 +274,30 @@ namespace arch {
           const real_t x3_H { metric.template convert<3, Crd::Cd, Crd::Ph>(
             i3_ + HALF) };
 
-          if constexpr (defines_dx1 && defines_dx2 && defines_dx3) {
+          if constexpr (::traits::fieldsetter::HasDx1<I, Dim::_3D> &&
+                        ::traits::fieldsetter::HasDx2<I, Dim::_3D> &&
+                        ::traits::fieldsetter::HasDx3<I, Dim::_3D>) {
             { // dx1
-              vec_t<Dim::_3D> d_PU { finit.dx1({ x1_H, x2_0, x3_0 }),
-                                     finit.dx2({ x1_H, x2_0, x3_0 }),
-                                     finit.dx3({ x1_H, x2_0, x3_0 }) };
-              vec_t<Dim::_3D> d_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>({ i1_ + HALF, i2_, i3_ },
-                                                         d_PU,
-                                                         d_U);
-              EM(i1, i2, i3, em::dx1) = d_U[0];
+              EM(i1, i2, i3, em::dx1) = finit.dx1({ x1_H, x2_0, x3_0 });
             }
             { // dx2
-              vec_t<Dim::_3D> d_PU { finit.dx1({ x1_0, x2_H, x3_0 }),
-                                     finit.dx2({ x1_0, x2_H, x3_0 }),
-                                     finit.dx3({ x1_0, x2_H, x3_0 }) };
-              vec_t<Dim::_3D> d_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>({ i1_, i2_ + HALF, i3_ },
-                                                         d_PU,
-                                                         d_U);
-              EM(i1, i2, i3, em::dx2) = d_U[1];
+              EM(i1, i2, i3, em::dx2) = finit.dx2({ x1_0, x2_H, x3_0 });
             }
             { // dx3
-              vec_t<Dim::_3D> d_PU { finit.dx1({ x1_0, x2_0, x3_H }),
-                                     finit.dx2({ x1_0, x2_0, x3_H }),
-                                     finit.dx3({ x1_0, x2_0, x3_H }) };
-              vec_t<Dim::_3D> d_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>({ i1_, i2_, i3_ + HALF },
-                                                         d_PU,
-                                                         d_U);
-              EM(i1, i2, i3, em::dx3) = d_U[2];
+              EM(i1, i2, i3, em::dx3) = finit.dx3({ x1_0, x2_0, x3_H });
             }
           }
-          if constexpr (defines_bx1 && defines_bx2 && defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_3D> &&
+                        ::traits::fieldsetter::HasBx2<I, Dim::_3D> &&
+                        ::traits::fieldsetter::HasBx3<I, Dim::_3D>) {
             { // bx1
-              vec_t<Dim::_3D> b_PU { finit.bx1({ x1_0, x2_H, x3_H }),
-                                     finit.bx2({ x1_0, x2_H, x3_H }),
-                                     finit.bx3({ x1_0, x2_H, x3_H }) };
-              vec_t<Dim::_3D> b_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>(
-                { i1_, i2_ + HALF, i3_ + HALF },
-                b_PU,
-                b_U);
-              EM(i1, i2, i3, em::bx1) = b_U[0];
+              EM(i1, i2, i3, em::bx1) = finit.bx1({ x1_0, x2_H, x3_H });
             }
             { // bx2
-              vec_t<Dim::_3D> b_PU { finit.bx1({ x1_H, x2_0, x3_H }),
-                                     finit.bx2({ x1_H, x2_0, x3_H }),
-                                     finit.bx3({ x1_H, x2_0, x3_H }) };
-              vec_t<Dim::_3D> b_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>(
-                { i1_ + HALF, i2_, i3_ + HALF },
-                b_PU,
-                b_U);
-              EM(i1, i2, i3, em::bx2) = b_U[1];
+              EM(i1, i2, i3, em::bx2) = finit.bx2({ x1_H, x2_0, x3_H });
             }
             { // bx3
-              vec_t<Dim::_3D> b_PU { finit.bx1({ x1_H, x2_H, x3_0 }),
-                                     finit.bx2({ x1_H, x2_H, x3_0 }),
-                                     finit.bx3({ x1_H, x2_H, x3_0 }) };
-              vec_t<Dim::_3D> b_U { ZERO };
-              metric.template transform<Idx::PU, Idx::U>(
-                { i1_ + HALF, i2_ + HALF, i3_ },
-                b_PU,
-                b_U);
-              EM(i1, i2, i3, em::bx3) = b_U[2];
+              EM(i1, i2, i3, em::bx3) = finit.bx3({ x1_H, x2_H, x3_0 });
             }
           }
         } else {
diff --git a/src/archetypes/particle_injector.h b/src/archetypes/particle_injector.h
index 24af59965..d41996393 100644
--- a/src/archetypes/particle_injector.h
+++ b/src/archetypes/particle_injector.h
@@ -22,6 +22,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
 
@@ -53,6 +55,7 @@ namespace arch {
    *   - array_t<real_t*>: maximum coordinates of the region in computational coords
    */
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert<M>
   auto DeduceRegion(const Domain<S, M>& domain, const boundaries_t<real_t>& box)
     -> std::tuple<bool, array_t<real_t*>, array_t<real_t*>> {
     if (not domain.mesh.Intersects(box)) {
@@ -107,6 +110,7 @@ namespace arch {
    *   - array_t<real_t*>: maximum coordinates of the region in computational coords
    */
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M>
   auto ComputeNumInject(const SimulationParams&     params,
                         const Domain<S, M>&         domain,
                         real_t                      number_density,
@@ -198,6 +202,8 @@ namespace arch {
    * @tparam ED2 Energy distribution type for species 2
    */
   template <SimEngine::type S, class M, class ED1, class ED2>
+    requires metric::traits::HasD<M> && traits::energydist::IsValid<ED1> &&
+             traits::energydist::IsValid<ED2>
   inline void InjectUniform(const SimulationParams&            params,
                             Domain<S, M>&                      domain,
                             const std::pair<spidx_t, spidx_t>& species,
@@ -205,9 +211,6 @@ namespace arch {
                             real_t                             number_density,
                             bool                        use_weights = false,
                             const boundaries_t<real_t>& box         = {}) {
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(ED1::is_energy_dist, "ED1 must be an energy distribution class");
-    static_assert(ED2::is_energy_dist, "ED2 must be an energy distribution class");
     raise::ErrorIf((M::CoordType != Coord::Cart) && (not use_weights),
                    "Weights must be used for non-Cartesian coordinates",
                    HERE);
@@ -278,7 +281,6 @@ namespace arch {
                              spidx_t                 spidx,
                              const std::map<std::string, std::vector<real_t>>& data,
                              bool use_weights = false) {
-    static_assert(M::is_metric, "M must be a metric class");
     const auto n_inject        = data.at("ux1").size();
     auto       injector_kernel = kernel::GlobalInjector_kernel<S, M>(
       local_domain.species[spidx - 1],
@@ -309,6 +311,8 @@ namespace arch {
    * @tparam SD Spatial distribution type
    */
   template <SimEngine::type S, class M, class ED1, class ED2, class SD>
+    requires metric::traits::HasD<M> && traits::energydist::IsValid<ED1> &&
+             traits::energydist::IsValid<ED2> && traits::spatialdist::IsValid<SD>
   inline void InjectNonUniform(const SimulationParams&            params,
                                Domain<S, M>&                      domain,
                                const std::pair<spidx_t, spidx_t>& species,
@@ -317,10 +321,6 @@ namespace arch {
                                real_t                      number_density,
                                bool                        use_weights = false,
                                const boundaries_t<real_t>& box         = {}) {
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(ED1::is_energy_dist, "ED1 must be an energy distribution class");
-    static_assert(ED2::is_energy_dist, "ED2 must be an energy distribution class");
-    static_assert(SD::is_spatial_dist, "SD must be a spatial distribution class");
     raise::ErrorIf((M::CoordType != Coord::Cart) && (not use_weights),
                    "Weights must be used for non-Cartesian coordinates",
                    HERE);
diff --git a/src/archetypes/problem_generator.h b/src/archetypes/problem_generator.h
index da116672d..fc22428e6 100644
--- a/src/archetypes/problem_generator.h
+++ b/src/archetypes/problem_generator.h
@@ -23,15 +23,16 @@
 #include "enums.h"
 #include "global.h"
 
-#include "framework/parameters.h"
+#include "metrics/traits.h"
+
+#include "framework/parameters/parameters.h"
 
 namespace arch {
   using namespace ntt;
 
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M> and metric::traits::HasCoordType<M>
   struct ProblemGenerator {
-    static_assert(M::is_metric, "M must be a metric class");
-    static constexpr bool      is_pgen { true };
     static constexpr Dimension D { M::Dim };
     static constexpr Coord     C { M::CoordType };
 
diff --git a/src/archetypes/spatial_dist.h b/src/archetypes/spatial_dist.h
index 68477208c..bf8abe9cd 100644
--- a/src/archetypes/spatial_dist.h
+++ b/src/archetypes/spatial_dist.h
@@ -23,13 +23,15 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace arch {
   using namespace ntt;
 
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M>
   struct SpatialDistribution {
-    static constexpr bool is_spatial_dist { true };
-    static_assert(M::is_metric, "M must be a metric class");
+    static constexpr auto D = M::Dim;
 
     SpatialDistribution(const M& metric) : metric { metric } {}
 
diff --git a/src/archetypes/tests/CMakeLists.txt b/src/archetypes/tests/CMakeLists.txt
index 9419847c5..4a5b501e1 100644
--- a/src/archetypes/tests/CMakeLists.txt
+++ b/src/archetypes/tests/CMakeLists.txt
@@ -27,3 +27,4 @@ gen_test(energy_dist)
 gen_test(spatial_dist)
 gen_test(field_setter)
 gen_test(powerlaw)
+gen_test(pgen)
diff --git a/src/archetypes/tests/pgen.cpp b/src/archetypes/tests/pgen.cpp
new file mode 100644
index 000000000..6ae574648
--- /dev/null
+++ b/src/archetypes/tests/pgen.cpp
@@ -0,0 +1,153 @@
+#include "enums.h"
+
+#include "utils/numeric.h"
+
+#include "metrics/minkowski.h"
+
+#include "archetypes/problem_generator.h"
+#include "archetypes/traits.h"
+#include "framework/domain/domain.h"
+#include "framework/parameters/parameters.h"
+
+#include <Kokkos_Core.hpp>
+
+#include <iostream>
+
+using namespace ntt;
+
+template <Dimension D>
+struct CustomFieldsetter {
+  Inline auto ex1(const coord_t<D>&) const -> real_t {
+    return ZERO;
+  }
+};
+
+template <Dimension D>
+struct ExtForce {
+  Inline auto fx1(spidx_t, simtime_t, const coord_t<D>&) const -> real_t {
+    return ZERO;
+  }
+};
+
+template <Dimension D>
+struct ExtCurrent {
+  Inline auto jx1(const coord_t<D>&) const -> real_t {
+    return ZERO;
+  }
+};
+
+template <SimEngine::type S, class M>
+struct CustomPgen : public arch::ProblemGenerator<S, M> {
+  CustomPgen(const SimulationParams& params = {})
+    : arch::ProblemGenerator<S, M> { params } {}
+
+  CustomFieldsetter<M::Dim> init_flds {};
+  ExtForce<M::Dim>          ext_force {};
+  ExtCurrent<M::Dim>        ext_current {};
+
+  void InitPrtls(Domain<S, M>&) {}
+
+  auto AtmFields(simtime_t) const -> CustomFieldsetter<M::Dim> {
+    return init_flds;
+  }
+
+  auto MatchFields(simtime_t) const -> CustomFieldsetter<M::Dim> {
+    return init_flds;
+  }
+
+  auto MatchFieldsInX1(simtime_t) const -> CustomFieldsetter<M::Dim> {
+    return init_flds;
+  }
+
+  auto MatchFieldsInX2(simtime_t) const -> CustomFieldsetter<M::Dim> {
+    return init_flds;
+  }
+
+  auto MatchFieldsInX3(simtime_t) const -> CustomFieldsetter<M::Dim> {
+    return init_flds;
+  }
+
+  auto FixFieldsConst(simtime_t, const bc_in&, ntt::em) const
+    -> std::pair<real_t, bool> {
+    return { ZERO, false };
+  }
+
+  void CustomPostStep(timestep_t, simtime_t, Domain<S, M>&) {}
+
+  void CustomFieldOutput(const std::string&,
+                         ndfield_t<M::Dim, 6>&,
+                         index_t,
+                         timestep_t,
+                         simtime_t,
+                         const Domain<S, M>&) {}
+
+  auto CustomStat(const std::string&, timestep_t, simtime_t, const Domain<S, M>&)
+    -> real_t {
+    return ZERO;
+  }
+};
+
+auto main(int argc, char* argv[]) -> int {
+  Kokkos::initialize(argc, argv);
+  try {
+    auto custom_pgen = CustomPgen<SimEngine::SRPIC, metric::Minkowski<Dim::_1D>> {};
+
+    if constexpr (not arch::traits::pgen::HasInitFlds<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have init_flds");
+    }
+    if constexpr (not arch::traits::pgen::HasInitPrtls<
+                    decltype(custom_pgen),
+                    Domain<SimEngine::SRPIC, metric::Minkowski<Dim::_1D>>>) {
+      throw std::runtime_error("CustomPgen should have InitPrtls");
+    }
+    if constexpr (not arch::traits::pgen::HasExtForce<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have ext_force");
+    }
+    if constexpr (not arch::traits::pgen::HasExtCurrent<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have ext_current");
+    }
+    if constexpr (not arch::traits::pgen::HasAtmFields<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have AtmFields");
+    }
+    if constexpr (not arch::traits::pgen::HasMatchFields<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have MatchFields");
+    }
+    if constexpr (
+      not arch::traits::pgen::HasMatchFieldsInX1<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have MatchFieldsInX1");
+    }
+    if constexpr (
+      not arch::traits::pgen::HasMatchFieldsInX2<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have MatchFieldsInX2");
+    }
+    if constexpr (
+      not arch::traits::pgen::HasMatchFieldsInX3<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have MatchFieldsInX3");
+    }
+    if constexpr (not arch::traits::pgen::HasFixFieldsConst<decltype(custom_pgen)>) {
+      throw std::runtime_error("CustomPgen should have FixFieldsConst");
+    }
+    if constexpr (not arch::traits::pgen::HasCustomPostStep<
+                    decltype(custom_pgen),
+                    Domain<SimEngine::SRPIC, metric::Minkowski<Dim::_1D>>>) {
+      throw std::runtime_error("CustomPgen should have CustomPostStep");
+    }
+    if constexpr (not arch::traits::pgen::HasCustomFieldOutput<
+                    decltype(custom_pgen),
+                    Domain<SimEngine::SRPIC, metric::Minkowski<Dim::_1D>>>) {
+      throw std::runtime_error("CustomPgen should have CustomFieldOutput");
+    }
+    if constexpr (not arch::traits::pgen::HasCustomStatOutput<
+                    decltype(custom_pgen),
+                    Domain<SimEngine::SRPIC, metric::Minkowski<Dim::_1D>>>) {
+      throw std::runtime_error("CustomPgen should have CustomStat");
+    }
+
+  } catch (std::exception& e) {
+    std::cerr << e.what() << std::endl;
+    Kokkos::finalize();
+    return 1;
+  }
+  Kokkos::finalize();
+  return 0;
+}
diff --git a/src/archetypes/traits.h b/src/archetypes/traits.h
new file mode 100644
index 000000000..a6a4ed151
--- /dev/null
+++ b/src/archetypes/traits.h
@@ -0,0 +1,160 @@
+/**
+ * @file archetypes/traits.h
+ * @brief Defines a set of traits to check if archetype classes satisfy certain conditions
+ * @implements
+ *   - arch::traits::energydist::IsValid<> - checks if energy distribution class has required operator()
+ *   - arch::traits::spatialdist::IsValid<> - checks if spatial distribution class has required operator()
+ *   - arch::traits::pgen::check_compatibility<> - checks if problem generator is compatible with given enums
+ *   - arch::traits::pgen::compatible_with<> - defines compatible enums for problem generator
+ *   - arch::traits::pgen::HasD<> - checks if problem generator has Dim static member
+ *   - arch::traits::pgen::HasInitFlds<> - checks if problem generator has init_flds member
+ *   - arch::traits::pgen::HasInitPrtls<> - checks if problem generator has InitPrtls method
+ *   - arch::traits::pgen::HasExtForce<> - checks if problem generator has ext_force member
+ *   - arch::traits::pgen::HasExtCurrent<> - checks if problem generator has ext_current member
+ *   - arch::traits::pgen::HasAtmFields<> - checks if problem generator has AtmFields method
+ *   - arch::traits::pgen::HasMatchFields<> - checks if problem generator has MatchFields method
+ *   - arch::traits::pgen::HasMatchFieldsInX1<> - checks if problem generator has MatchFieldsInX1 method
+ *   - arch::traits::pgen::HasMatchFieldsInX2<> - checks if problem generator has MatchFieldsInX2 method
+ *   - arch::traits::pgen::HasMatchFieldsInX3<> - checks if problem generator has MatchFieldsInX3 method
+ *   - arch::traits::pgen::HasFixFieldsConst<> - checks if problem generator has FixFieldsConst method
+ *   - arch::traits::pgen::HasCustomPostStep<> - checks if problem generator has CustomPostStep method
+ *   - arch::traits::pgen::HasCustomFieldOutput<> - checks if problem generator has CustomFieldOutput method
+ *   - arch::traits::pgen::HasCustomStatOutput<> - checks if problem generator has CustomStat method
+ * @namespaces:
+ *   - arch::traits::
+ */
+#ifndef ARCHETYPES_TRAITS_H
+#define ARCHETYPES_TRAITS_H
+
+#include "global.h"
+
+#include "arch/kokkos_aliases.h"
+
+namespace arch {
+  namespace traits {
+
+    namespace energydist {
+
+      template <class ED>
+      concept IsValid = requires(const ED&             edist,
+                                 const coord_t<ED::D>& x_Ph,
+                                 vec_t<Dim::_3D>&      v) {
+        { edist(x_Ph, v) } -> std::same_as<void>;
+      };
+
+    } // namespace energydist
+
+    namespace spatialdist {
+
+      template <class SD>
+      concept IsValid = requires(const SD& sdist, const coord_t<SD::D>& x_Ph) {
+        { sdist(x_Ph) } -> std::convertible_to<real_t>;
+      };
+
+    } // namespace spatialdist
+
+    namespace pgen {
+
+      // checking compat for the problem generator + engine
+      template <int N>
+      struct check_compatibility {
+        template <int... Is>
+        static constexpr bool value(std::integer_sequence<int, Is...>) {
+          return ((Is == N) || ...);
+        }
+      };
+
+      template <int... Is>
+      struct compatible_with {
+        static constexpr auto value = std::integer_sequence<int, Is...> {};
+      };
+
+      template <class PG>
+      concept HasD = requires {
+        { PG::D } -> std::convertible_to<Dimension>;
+      };
+
+      template <class PG>
+      concept HasInitFlds = requires(const PG& pgen) { pgen.init_flds; };
+
+      template <class PG, class D>
+      concept HasInitPrtls = requires(PG& pgen, D& domain) {
+        { pgen.InitPrtls(domain) } -> std::same_as<void>;
+      };
+
+      template <class PG>
+      concept HasExtForce = requires(const PG& pgen) { pgen.ext_force; };
+
+      template <class PG>
+      concept HasExtCurrent = requires(const PG& pgen) { pgen.ext_current; };
+
+      template <class PG>
+      concept HasAtmFields = requires(const PG& pgen, simtime_t time) {
+        pgen.AtmFields(time);
+      };
+
+      template <class PG>
+      concept HasMatchFields = requires(const PG& pgen, simtime_t time) {
+        pgen.MatchFields(time);
+      };
+
+      template <class PG>
+      concept HasMatchFieldsInX1 = requires(const PG& pgen, simtime_t time) {
+        pgen.MatchFieldsInX1(time);
+      };
+
+      template <class PG>
+      concept HasMatchFieldsInX2 = requires(const PG& pgen, simtime_t time) {
+        pgen.MatchFieldsInX2(time);
+      };
+
+      template <class PG>
+      concept HasMatchFieldsInX3 = requires(const PG& pgen, simtime_t time) {
+        pgen.MatchFieldsInX3(time);
+      };
+
+      template <class PG>
+      concept HasFixFieldsConst = requires(const PG&    pgen,
+                                           simtime_t    time,
+                                           const bc_in& bc,
+                                           ntt::em      comp) {
+        {
+          pgen.FixFieldsConst(time, bc, comp)
+        } -> std::convertible_to<std::pair<real_t, bool>>;
+      };
+
+      template <class PG, class D>
+      concept HasCustomPostStep = requires(PG&        pgen,
+                                           timestep_t s,
+                                           simtime_t  t,
+                                           D&         domain) {
+        { pgen.CustomPostStep(s, t, domain) } -> std::same_as<void>;
+      };
+
+      template <class PG, class D>
+      concept HasCustomFieldOutput = requires(PG&                  pgen,
+                                              const std::string&   name,
+                                              ndfield_t<PG::D, 6>& buff,
+                                              index_t              idx,
+                                              timestep_t           step,
+                                              simtime_t            time,
+                                              const D&             dom) {
+        {
+          pgen.CustomFieldOutput(name, buff, idx, step, time, dom)
+        } -> std::same_as<void>;
+      };
+
+      template <class PG, class D>
+      concept HasCustomStatOutput = requires(PG&                pgen,
+                                             const std::string& name,
+                                             timestep_t         s,
+                                             simtime_t          t,
+                                             const D&           dom) {
+        { pgen.CustomStat(name, s, t, dom) } -> std::convertible_to<real_t>;
+      };
+
+    } // namespace pgen
+  } // namespace traits
+} // namespace arch
+
+#endif // ARCHETYPES_TRAITS_H
diff --git a/src/archetypes/utils.h b/src/archetypes/utils.h
index b1a29cb71..14ac7d8f8 100644
--- a/src/archetypes/utils.h
+++ b/src/archetypes/utils.h
@@ -17,7 +17,7 @@
 #include "archetypes/energy_dist.h"
 #include "archetypes/particle_injector.h"
 #include "framework/domain/domain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 
 #include <utility>
 
@@ -45,7 +45,6 @@ namespace arch {
     const std::pair<std::vector<real_t>, std::vector<real_t>>& drift_four_vels = {{ ZERO, ZERO, ZERO }, { ZERO, ZERO, ZERO }},
     bool                               use_weights = false,
     const boundaries_t<real_t>&        box         = {}) {
-    static_assert(M::is_metric, "M must be a metric class");
 
     const auto mass_1        = domain.species[species.first - 1].mass();
     const auto mass_2        = domain.species[species.second - 1].mass();
@@ -93,7 +92,6 @@ namespace arch {
     const std::pair<std::vector<real_t>, std::vector<real_t>>& drift_four_vels = {{ ZERO, ZERO, ZERO }, { ZERO, ZERO, ZERO }},
     bool                               use_weights = false,
     const boundaries_t<real_t>&        box         = {}) {
-    static_assert(M::is_metric, "M must be a metric class");
 
     InjectUniformMaxwellians<S, M>(params,
                                    domain,
diff --git a/src/engines/CMakeLists.txt b/src/engines/CMakeLists.txt
index 4cef18630..5b2edebdc 100644
--- a/src/engines/CMakeLists.txt
+++ b/src/engines/CMakeLists.txt
@@ -4,9 +4,7 @@
 #
 # @sources:
 #
-# * engine_printer.cpp
-# * engine_init.cpp
-# * engine_run.cpp
+# * reporter.cpp
 #
 # @includes:
 #
@@ -32,8 +30,7 @@
 # ------------------------------
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-set(SOURCES ${SRC_DIR}/engine_printer.cpp ${SRC_DIR}/engine_init.cpp
-            ${SRC_DIR}/engine_run.cpp)
+set(SOURCES ${SRC_DIR}/reporter.cpp)
 add_library(ntt_engines ${SOURCES})
 
 set(libs ntt_global ntt_framework ntt_metrics ntt_archetypes ntt_kernels
@@ -43,7 +40,7 @@ if(${output})
 endif()
 add_dependencies(ntt_engines ${libs})
 target_link_libraries(ntt_engines PUBLIC ${libs})
-target_compile_definitions(ntt_engines PRIVATE PGEN=\"${PGEN}\")
+target_compile_definitions(ntt_engines PUBLIC PGEN=\"${PGEN}\")
 
 target_include_directories(
   ntt_engines
diff --git a/src/engines/engine.hpp b/src/engines/engine.hpp
index 17103f1de..f232c7980 100644
--- a/src/engines/engine.hpp
+++ b/src/engines/engine.hpp
@@ -3,9 +3,6 @@
  * @brief Base simulation class which just initializes the metadomain
  * @implements
  *   - ntt::Engine<>
- * @cpp:
- *   - engine_init.cpp
- *   - engine_printer.cpp
  * @namespaces:
  *   - ntt::
  * @macros:
@@ -21,22 +18,35 @@
 #include "enums.h"
 #include "global.h"
 
-#include "arch/traits.h"
-#include "utils/error.h"
+#include "arch/mpi_aliases.h"
+#include "utils/diag.h"
+#include "utils/reporter.h"
 #include "utils/timer.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
+#include "archetypes/field_setter.h"
+#include "archetypes/traits.h"
+#include "engines/reporter.h"
+#include "engines/traits.h"
 #include "framework/containers/species.h"
+#include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 
 #include "pgen.hpp"
 
+#if defined(OUTPUT_ENABLED)
+  #include <adios2.h>
+#endif
+
 #include <Kokkos_Core.hpp>
 
+#include <string>
+#include <vector>
+
 #if defined(OUTPUT_ENABLED)
   #include <adios2.h>
-  #include <adios2/cxx11/KokkosView.h>
+  #include <adios2/cxx/KokkosView.h>
 #endif // OUTPUT_ENABLED
 
 #if defined(MPI_ENABLED)
@@ -49,9 +59,8 @@
 namespace ntt {
 
   template <SimEngine::type S, class M>
+    requires traits::engine::IsCompatibleWithEngine<S, M, user::PGen>
   class Engine {
-    static_assert(M::is_metric, "template arg for Engine class has to be a metric");
-    static_assert(user::PGen<S, M>::is_pgen, "unrecognized problem generator");
 
   protected:
 #if defined(OUTPUT_ENABLED)
@@ -76,14 +85,7 @@ namespace ntt {
     timestep_t       step;
 
   public:
-    static constexpr bool pgen_is_ok {
-      traits::check_compatibility<S>::value(user::PGen<S, M>::engines) and
-      traits::check_compatibility<M::MetricType>::value(user::PGen<S, M>::metrics) and
-      traits::check_compatibility<M::Dim>::value(user::PGen<S, M>::dimensions)
-    };
-
     static constexpr Dimension D { M::Dim };
-    static constexpr bool      is_engine { true };
 
     Engine(const SimulationParams& params)
       : m_params { params }
@@ -108,9 +110,7 @@ namespace ntt {
       , start_step { m_params.get<timestep_t>("checkpoint.start_step") }
       , start_time { m_params.get<simtime_t>("checkpoint.start_time") }
       , time { start_time }
-      , step { start_step } {
-      raise::ErrorIf(not pgen_is_ok, "Problem generator is not compatible with the picked engine/metric/dimension", HERE);
-    }
+      , step { start_step } {}
 
     ~Engine() = default;
 
@@ -120,8 +120,249 @@ namespace ntt {
     virtual void step_forward(timer::Timers&, Domain<S, M>&) = 0;
 
     void run();
+
+    auto engineParams() const -> prm::Parameters {
+      auto parameters = prm::Parameters {};
+      parameters.set("dt", static_cast<real_t>(dt));
+      parameters.set("time", static_cast<simtime_t>(time));
+      return parameters;
+    }
   };
 
+  template <SimEngine::type S, class M>
+    requires traits::engine::IsCompatibleWithEngine<S, M, user::PGen>
+  void Engine<S, M>::init() {
+    m_metadomain.InitStatsWriter(m_params, is_resuming);
+#if defined(OUTPUT_ENABLED)
+    m_metadomain.InitWriter(&m_adios, m_params);
+    m_metadomain.InitCheckpointWriter(&m_adios, m_params);
+#endif
+    logger::Checkpoint("Initializing Engine", HERE);
+    if (not is_resuming) {
+      // start a new simulation with initial conditions
+      logger::Checkpoint("Loading initial conditions", HERE);
+      if constexpr (arch::traits::pgen::HasInitFlds<user::PGen<S, M>>) {
+        logger::Checkpoint("Initializing fields from problem generator", HERE);
+        m_metadomain.runOnLocalDomains([&](auto& loc_dom) {
+          Kokkos::parallel_for(
+            "InitFields",
+            loc_dom.mesh.rangeActiveCells(),
+            arch::SetEMFields_kernel<decltype(m_pgen.init_flds), S, M> {
+              loc_dom.fields.em,
+              m_pgen.init_flds,
+              loc_dom.mesh.metric });
+        });
+      }
+      if constexpr (
+        arch::traits::pgen::HasInitPrtls<user::PGen<S, M>, Domain<S, M>>) {
+        logger::Checkpoint("Initializing particles from problem generator", HERE);
+        m_metadomain.runOnLocalDomains([&](auto& loc_dom) {
+          m_pgen.InitPrtls(loc_dom);
+        });
+      }
+    } else {
+#if defined(OUTPUT_ENABLED)
+      // read simulation data from the checkpoint
+      raise::ErrorIf(
+        m_params.template get<timestep_t>("checkpoint.start_step") == 0,
+        "Resuming simulation from a checkpoint requires a valid start_step",
+        HERE);
+      logger::Checkpoint("Resuming simulation from a checkpoint", HERE);
+      m_metadomain.ContinueFromCheckpoint(&m_adios, m_params);
+#else
+      raise::Error(
+        "Resuming simulation from a checkpoint requires -D output=ON",
+        HERE);
+#endif
+    }
+    print_report();
+  }
+
+  template <SimEngine::type S, class M>
+    requires traits::engine::IsCompatibleWithEngine<S, M, user::PGen>
+  void Engine<S, M>::print_report() const {
+    const auto colored_stdout = m_params.template get<bool>(
+      "diagnostics.colored_stdout");
+    std::string report = "";
+    CallOnce(
+      [&](auto& metadomain, auto& params) {
+        const auto pgen  = std::string(PGEN);
+        report          += reporter::Backend();
+
+        report += ReportSimulationConfig(params,
+                                         pgen,
+                                         S,
+                                         Metric(M::MetricType),
+                                         dt,
+                                         runtime,
+                                         max_steps,
+                                         metadomain.ndomains_per_dim(),
+                                         metadomain.ndomains());
+        if (metadomain.species_params().size() > 0) {
+          report += "\n";
+          reporter::AddCategory(report, 4, "Particles");
+        }
+        for (const auto& species : metadomain.species_params()) {
+          report += species.Report();
+        }
+        report.pop_back();
+      },
+      m_metadomain,
+      m_params);
+    info::Print(report, colored_stdout);
+
+    report = "\n";
+    CallOnce([&]() {
+      reporter::AddCategory(report, 4, "Domains");
+      report.pop_back();
+    });
+    info::Print(report, colored_stdout);
+
+    for (unsigned int idx { 0 }; idx < m_metadomain.ndomains(); ++idx) {
+      auto is_local = false;
+      for (const auto& lidx : m_metadomain.l_subdomain_indices()) {
+        is_local |= (idx == lidx);
+      }
+      if (is_local) {
+        const auto& domain = m_metadomain.subdomain(idx);
+        report             = domain.Report();
+        if (idx == m_metadomain.ndomains() - 1) {
+          report += "\n\n";
+        }
+        info::Print(report, colored_stdout, true, false);
+      }
+#if defined(MPI_ENABLED)
+      MPI_Barrier(MPI_COMM_WORLD);
+#endif
+    }
+  }
+
+  template <SimEngine::type S, class M>
+    requires traits::engine::IsCompatibleWithEngine<S, M, user::PGen>
+  void Engine<S, M>::run() {
+    init();
+
+    auto timers = timer::Timers {
+      { "FieldSolver",
+       "CurrentFiltering", "CurrentDeposit",
+       "ParticlePusher", "FieldBoundaries",
+       "ParticleBoundaries", "Communications",
+       "Injector", "Custom",
+       "PrtlClear", "Output",
+       "Checkpoint" },
+      []() {
+        Kokkos::fence();
+       },
+      m_params.get<bool>("diagnostics.blocking_timers")
+    };
+    const auto diag_interval = m_params.template get<timestep_t>(
+      "diagnostics.interval");
+
+    auto       time_history   = pbar::DurationHistory { 1000 };
+    const auto clear_interval = m_params.template get<timestep_t>(
+      "particles.clear_interval");
+
+    // main algorithm loop
+    while (step < max_steps) {
+      // run the engine-dependent algorithm step
+      m_metadomain.runOnLocalDomains([&timers, this](auto& dom) {
+        step_forward(timers, dom);
+      });
+      // poststep (if defined)
+      if constexpr (
+        arch::traits::pgen::HasCustomPostStep<decltype(m_pgen), Domain<S, M>>) {
+        timers.start("Custom");
+        m_metadomain.runOnLocalDomains([&timers, this](auto& dom) {
+          m_pgen.CustomPostStep(step, time, dom);
+        });
+        timers.stop("Custom");
+      }
+      auto print_prtl_clear = (clear_interval > 0 and
+                               step % clear_interval == 0 and step > 0);
+
+      // advance time & step
+      time += dt;
+      ++step;
+
+      auto print_output     = false;
+      auto print_checkpoint = false;
+#if defined(OUTPUT_ENABLED)
+      timers.start("Output");
+      if constexpr (
+        arch::traits::pgen::HasCustomFieldOutput<decltype(m_pgen), Domain<S, M>>) {
+        auto lambda_custom_field_output = [&](const std::string&    name,
+                                              ndfield_t<M::Dim, 6>& buff,
+                                              index_t               idx,
+                                              timestep_t            step,
+                                              simtime_t             time,
+                                              const Domain<S, M>&   dom) {
+          m_pgen.CustomFieldOutput(name, buff, idx, step, time, dom);
+        };
+        print_output &= m_metadomain.Write(m_params,
+                                           step,
+                                           step - 1,
+                                           time,
+                                           time - dt,
+                                           lambda_custom_field_output);
+      } else {
+        print_output &= m_metadomain.Write(m_params, step, step - 1, time, time - dt);
+      }
+      if constexpr (
+        arch::traits::pgen::HasCustomStatOutput<decltype(m_pgen), Domain<S, M>>) {
+        auto lambda_custom_stat = [&](const std::string&  name,
+                                      timestep_t          step,
+                                      simtime_t           time,
+                                      const Domain<S, M>& dom) -> real_t {
+          return m_pgen.CustomStat(name, step, time, dom);
+        };
+        print_output &= m_metadomain.WriteStats(m_params,
+                                                step,
+                                                step - 1,
+                                                time,
+                                                time - dt,
+                                                lambda_custom_stat);
+      } else {
+        print_output &= m_metadomain.WriteStats(m_params,
+                                                step,
+                                                step - 1,
+                                                time,
+                                                time - dt);
+      }
+      timers.stop("Output");
+
+      timers.start("Checkpoint");
+      print_checkpoint = m_metadomain.WriteCheckpoint(m_params,
+                                                      step,
+                                                      step - 1,
+                                                      time,
+                                                      time - dt);
+      timers.stop("Checkpoint");
+#endif
+
+      // advance time_history
+      time_history.tick();
+      // print timestep report
+      if (diag_interval > 0 and step % diag_interval == 0) {
+        diag::printDiagnostics(
+          step - 1,
+          max_steps,
+          time - dt,
+          dt,
+          timers,
+          time_history,
+          m_metadomain.l_ncells(),
+          m_metadomain.species_labels(),
+          m_metadomain.l_npart_perspec(),
+          m_metadomain.l_maxnpart_perspec(),
+          print_prtl_clear,
+          print_output,
+          print_checkpoint,
+          m_params.get<bool>("diagnostics.colored_stdout"));
+      }
+      timers.resetAll();
+    }
+  }
+
 } // namespace ntt
 
 #endif // ENGINES_ENGINE_H
diff --git a/src/engines/engine_init.cpp b/src/engines/engine_init.cpp
deleted file mode 100644
index f98b117dd..000000000
--- a/src/engines/engine_init.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "enums.h"
-#include "global.h"
-
-#include "arch/traits.h"
-
-#include "archetypes/field_setter.h"
-#include "framework/specialization_registry.h"
-
-#include "engines/engine.hpp"
-
-#include <Kokkos_Core.hpp>
-
-#include <string>
-
-namespace ntt {
-
-  template <SimEngine::type S, class M>
-  void Engine<S, M>::init() {
-    if constexpr (pgen_is_ok) {
-      m_metadomain.InitStatsWriter(m_params, is_resuming);
-#if defined(OUTPUT_ENABLED)
-      m_metadomain.InitWriter(&m_adios, m_params);
-      m_metadomain.InitCheckpointWriter(&m_adios, m_params);
-#endif
-      logger::Checkpoint("Initializing Engine", HERE);
-      if (not is_resuming) {
-        // start a new simulation with initial conditions
-        logger::Checkpoint("Loading initial conditions", HERE);
-        if constexpr (
-          traits::has_member<traits::pgen::init_flds_t, user::PGen<S, M>>::value) {
-          logger::Checkpoint("Initializing fields from problem generator", HERE);
-          m_metadomain.runOnLocalDomains([&](auto& loc_dom) {
-            Kokkos::parallel_for(
-              "InitFields",
-              loc_dom.mesh.rangeActiveCells(),
-              arch::SetEMFields_kernel<decltype(m_pgen.init_flds), S, M> {
-                loc_dom.fields.em,
-                m_pgen.init_flds,
-                loc_dom.mesh.metric });
-          });
-        }
-        if constexpr (
-          traits::has_member<traits::pgen::init_prtls_t, user::PGen<S, M>>::value) {
-          logger::Checkpoint("Initializing particles from problem generator", HERE);
-          m_metadomain.runOnLocalDomains([&](auto& loc_dom) {
-            m_pgen.InitPrtls(loc_dom);
-          });
-        }
-      } else {
-#if defined(OUTPUT_ENABLED)
-        // read simulation data from the checkpoint
-        raise::ErrorIf(
-          m_params.template get<timestep_t>("checkpoint.start_step") == 0,
-          "Resuming simulation from a checkpoint requires a valid start_step",
-          HERE);
-        logger::Checkpoint("Resuming simulation from a checkpoint", HERE);
-        m_metadomain.ContinueFromCheckpoint(&m_adios, m_params);
-#else
-        raise::Error(
-          "Resuming simulation from a checkpoint requires -D output=ON",
-          HERE);
-#endif
-      }
-    }
-    print_report();
-  }
-
-#define ENGINE_INIT(S, M, D) template class Engine<S, M<D>>;
-
-  NTT_FOREACH_SPECIALIZATION(ENGINE_INIT)
-
-#undef ENGINE_INIT
-
-} // namespace ntt
diff --git a/src/engines/engine_printer.cpp b/src/engines/engine_printer.cpp
deleted file mode 100644
index f3d6f3b38..000000000
--- a/src/engines/engine_printer.cpp
+++ /dev/null
@@ -1,500 +0,0 @@
-#include "enums.h"
-#include "global.h"
-
-#include "arch/directions.h"
-#include "arch/mpi_aliases.h"
-#include "utils/colors.h"
-#include "utils/formatting.h"
-
-#include "framework/specialization_registry.h"
-
-#include "engines/engine.hpp"
-
-#if defined(CUDA_ENABLED)
-  #include <cuda_runtime.h>
-#elif defined(HIP_ENABLED)
-  #include <hip/hip_runtime.h>
-#endif
-
-#if defined(OUTPUT_ENABLED)
-  #include <adios2.h>
-#endif
-
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace ntt {
-
-  namespace {
-    void add_header(std::string&                    report,
-                    const std::vector<std::string>& lines,
-                    const std::vector<const char*>& colors) {
-      report += fmt::format("%s╔%s╗%s\n",
-                            color::BRIGHT_BLACK,
-                            fmt::repeat("═", 58).c_str(),
-                            color::RESET);
-      for (auto i { 0u }; i < lines.size(); ++i) {
-        report += fmt::format("%s║%s %s%s%s%s%s║%s\n",
-                              color::BRIGHT_BLACK,
-                              color::RESET,
-                              colors[i],
-                              lines[i].c_str(),
-                              color::RESET,
-                              fmt::repeat(" ", 57 - lines[i].size()).c_str(),
-                              color::BRIGHT_BLACK,
-                              color::RESET);
-      }
-      report += fmt::format("%s╚%s╝%s\n",
-                            color::BRIGHT_BLACK,
-                            fmt::repeat("═", 58).c_str(),
-                            color::RESET);
-    }
-
-    void add_category(std::string& report, unsigned short indent, const char* name) {
-      report += fmt::format("%s%s%s%s\n",
-                            std::string(indent, ' ').c_str(),
-                            color::BLUE,
-                            name,
-                            color::RESET);
-    }
-
-    void add_subcategory(std::string& report, unsigned short indent, const char* name) {
-      report += fmt::format("%s%s-%s %s:\n",
-                            std::string(indent, ' ').c_str(),
-                            color::BRIGHT_BLACK,
-                            color::RESET,
-                            name);
-    }
-
-    void add_label(std::string& report, unsigned short indent, const char* label) {
-      report += fmt::format("%s%s\n", std::string(indent, ' ').c_str(), label);
-    }
-
-    template <typename... Args>
-    void add_param(std::string&   report,
-                   unsigned short indent,
-                   const char*    name,
-                   const char*    format,
-                   Args... args) {
-      report += fmt::format("%s%s-%s %s: %s%s%s\n",
-                            std::string(indent, ' ').c_str(),
-                            color::BRIGHT_BLACK,
-                            color::RESET,
-                            name,
-                            color::BRIGHT_YELLOW,
-                            fmt::format(format, args...).c_str(),
-                            color::RESET);
-    }
-
-    template <typename... Args>
-    void add_unlabeled_param(std::string&   report,
-                             unsigned short indent,
-                             const char*    name,
-                             const char*    format,
-                             Args... args) {
-      report += fmt::format("%s%s: %s%s%s\n",
-                            std::string(indent, ' ').c_str(),
-                            name,
-                            color::BRIGHT_YELLOW,
-                            fmt::format(format, args...).c_str(),
-                            color::RESET);
-    }
-
-    auto bytes_to_human_readable(
-      std::size_t bytes) -> std::pair<double, std::string> {
-      const std::vector<std::string> units { "B", "KB", "MB", "GB", "TB" };
-      idx_t                          unit_idx = 0;
-      auto                           size     = static_cast<double>(bytes);
-      while ((size >= 1024.0) and (unit_idx < units.size() - 1)) {
-        size /= 1024.0;
-        ++unit_idx;
-      }
-      return { size, units[unit_idx] };
-    }
-  } // namespace
-
-  template <SimEngine::type S, class M>
-  void Engine<S, M>::print_report() const {
-    const auto colored_stdout = m_params.template get<bool>(
-      "diagnostics.colored_stdout");
-    std::string report = "";
-    CallOnce(
-      [&](auto& metadomain, auto& params) {
-#if defined(MPI_ENABLED)
-        int mpi_v, mpi_subv;
-        MPI_Get_version(&mpi_v, &mpi_subv);
-        const std::string mpi_version = fmt::format("%d.%d", mpi_v, mpi_subv);
-#else  // not MPI_ENABLED
-        const std::string mpi_version = "OFF";
-#endif // MPI_ENABLED
-
-        const auto entity_version = "Entity v" + std::string(ENTITY_VERSION);
-        const auto hash           = std::string(ENTITY_GIT_HASH);
-        const auto pgen           = std::string(PGEN);
-        const auto nspec          = metadomain.species_params().size();
-        const auto precision      = (sizeof(real_t) == 4) ? "single" : "double";
-
-#if defined(__clang__)
-        const std::string ccx = "Clang/LLVM " __clang_version__;
-#elif defined(__ICC) || defined(__INTEL_COMPILER)
-        const std::string ccx = "Intel ICC/ICPC " __VERSION__;
-#elif defined(__GNUC__) || defined(__GNUG__)
-        const std::string ccx = "GNU GCC/G++ " __VERSION__;
-#elif defined(__HP_cc) || defined(__HP_aCC)
-        const std::string ccx = "Hewlett-Packard C/aC++ " __HP_aCC;
-#elif defined(__IBMC__) || defined(__IBMCPP__)
-        const std::string ccx = "IBM XL C/C++ " __IBMCPP__;
-#elif defined(_MSC_VER)
-        const std::string ccx = "Microsoft Visual Studio " _MSC_VER;
-#else
-        const std::string ccx = "Unknown compiler";
-#endif
-        std::string cpp_standard;
-        if (__cplusplus == 202101L) {
-          cpp_standard = "C++23";
-        } else if (__cplusplus == 202002L) {
-          cpp_standard = "C++20";
-        } else if (__cplusplus == 201703L) {
-          cpp_standard = "C++17";
-        } else if (__cplusplus == 201402L) {
-          cpp_standard = "C++14";
-        } else if (__cplusplus == 201103L) {
-          cpp_standard = "C++11";
-        } else if (__cplusplus == 199711L) {
-          cpp_standard = "C++98";
-        } else {
-          cpp_standard = "pre-standard " + std::to_string(__cplusplus);
-        }
-
-#if defined(CUDA_ENABLED)
-        int cuda_v;
-        cudaRuntimeGetVersion(&cuda_v);
-        const auto major { cuda_v / 1000 };
-        const auto minor { cuda_v % 1000 / 10 };
-        const auto patch { cuda_v % 10 };
-        const auto cuda_version = fmt::format("%d.%d.%d", major, minor, patch);
-#elif defined(HIP_ENABLED)
-        int  hip_v;
-        auto status = hipDriverGetVersion(&hip_v);
-        raise::ErrorIf(status != hipSuccess,
-                       "hipDriverGetVersion failed with error code %d",
-                       HERE);
-        const auto major { hip_v / 10000000 };
-        const auto minor { (hip_v % 10000000) / 100000 };
-        const auto patch { hip_v % 100000 };
-        const auto hip_version = fmt::format("%d.%d.%d", major, minor, patch);
-#endif
-
-        const auto kokkos_version = fmt::format("%d.%d.%d",
-                                                KOKKOS_VERSION / 10000,
-                                                KOKKOS_VERSION / 100 % 100,
-                                                KOKKOS_VERSION % 100);
-
-#if defined(OUTPUT_ENABLED)
-        const std::string adios2_version = fmt::format("%d.%d.%d",
-                                                       ADIOS2_VERSION / 10000,
-                                                       ADIOS2_VERSION / 100 % 100,
-                                                       ADIOS2_VERSION % 100);
-#else // not OUTPUT_ENABLED
-        const std::string adios2_version = "OFF";
-#endif
-
-#if defined(DEBUG)
-        const std::string dbg = "ON";
-#else // not DEBUG
-        const std::string dbg = "OFF";
-#endif
-
-        report += "\n\n";
-        add_header(report, { entity_version }, { color::BRIGHT_GREEN });
-        report += "\n";
-
-        /*
-         * Backend
-         */
-        add_category(report, 4, "Backend");
-        add_param(report, 4, "Build hash", "%s", hash.c_str());
-        add_param(report, 4, "CXX", "%s [%s]", ccx.c_str(), cpp_standard.c_str());
-#if defined(CUDA_ENABLED)
-        add_param(report, 4, "CUDA", "%s", cuda_version.c_str());
-#elif defined(HIP_VERSION)
-        add_param(report, 4, "HIP", "%s", hip_version.c_str());
-#endif
-        add_param(report, 4, "MPI", "%s", mpi_version.c_str());
-#if defined(MPI_ENABLED) && defined(DEVICE_ENABLED)
-  #if defined(GPU_AWARE_MPI)
-        const std::string gpu_aware_mpi = "ON";
-  #else
-        const std::string gpu_aware_mpi = "OFF";
-  #endif
-        add_param(report, 4, "GPU-aware MPI", "%s", gpu_aware_mpi.c_str());
-#endif
-        add_param(report, 4, "Kokkos", "%s", kokkos_version.c_str());
-        add_param(report, 4, "ADIOS2", "%s", adios2_version.c_str());
-        add_param(report, 4, "Precision", "%s", precision);
-        add_param(report, 4, "Debug", "%s", dbg.c_str());
-        report += "\n";
-
-        /*
-         * Compilation flags
-         */
-        add_category(report, 4, "Compilation flags");
-#if defined(SINGLE_PRECISION)
-        add_param(report, 4, "SINGLE_PRECISION", "%s", "ON");
-#else
-        add_param(report, 4, "SINGLE_PRECISION", "%s", "OFF");
-#endif
-
-#if defined(OUTPUT_ENABLED)
-        add_param(report, 4, "OUTPUT_ENABLED", "%s", "ON");
-#else
-        add_param(report, 4, "OUTPUT_ENABLED", "%s", "OFF");
-#endif
-
-#if defined(DEBUG)
-        add_param(report, 4, "DEBUG", "%s", "ON");
-#else
-        add_param(report, 4, "DEBUG", "%s", "OFF");
-#endif
-
-#if defined(CUDA_ENABLED)
-        add_param(report, 4, "CUDA_ENABLED", "%s", "ON");
-#else
-        add_param(report, 4, "CUDA_ENABLED", "%s", "OFF");
-#endif
-
-#if defined(HIP_ENABLED)
-        add_param(report, 4, "HIP_ENABLED", "%s", "ON");
-#else
-        add_param(report, 4, "HIP_ENABLED", "%s", "OFF");
-#endif
-
-#if defined(DEVICE_ENABLED)
-        add_param(report, 4, "DEVICE_ENABLED", "%s", "ON");
-#else
-        add_param(report, 4, "DEVICE_ENABLED", "%s", "OFF");
-#endif
-
-#if defined(MPI_ENABLED)
-        add_param(report, 4, "MPI_ENABLED", "%s", "ON");
-#else
-        add_param(report, 4, "MPI_ENABLED", "%s", "OFF");
-#endif
-
-#if defined(GPU_AWARE_MPI)
-        add_param(report, 4, "GPU_AWARE_MPI", "%s", "ON");
-#else
-        add_param(report, 4, "GPU_AWARE_MPI", "%s", "OFF");
-#endif
-        report += "\n";
-
-        /*
-         * Simulation configs
-         */
-        add_category(report, 4, "Configuration");
-        add_param(report,
-                  4,
-                  "Name",
-                  "%s",
-                  params.template get<std::string>("simulation.name").c_str());
-        add_param(report, 4, "Problem generator", "%s", pgen.c_str());
-        add_param(report, 4, "Engine", "%s", SimEngine(S).to_string());
-        add_param(report, 4, "Metric", "%s", Metric(M::MetricType).to_string());
-#if SHAPE_ORDER == 0
-        add_param(report, 4, "Deposit", "%s", "zigzag");
-#else
-        add_param(report, 4, "Deposit", "%s", "esirkepov");
-        add_param(report, 4, "Interpolation order", "%i", SHAPE_ORDER);
-#endif
-        add_param(report, 4, "Timestep [dt]", "%.3e", dt);
-        add_param(report, 4, "Runtime", "%.3e [%d steps]", runtime, max_steps);
-        report += "\n";
-        add_category(report, 4, "Global domain");
-        add_param(report,
-                  4,
-                  "Resolution",
-                  "%s",
-                  params.template stringize<ncells_t>("grid.resolution").c_str());
-        add_param(report,
-                  4,
-                  "Extent",
-                  "%s",
-                  params.template stringize<real_t>("grid.extent").c_str());
-        add_param(report,
-                  4,
-                  "Fiducial cell size [dx0]",
-                  "%.3e",
-                  params.template get<real_t>("scales.dx0"));
-        add_subcategory(report, 4, "Boundary conditions");
-        add_param(
-          report,
-          6,
-          "Fields",
-          "%s",
-          params.template stringize<FldsBC>("grid.boundaries.fields").c_str());
-        add_param(
-          report,
-          6,
-          "Particles",
-          "%s",
-          params.template stringize<PrtlBC>("grid.boundaries.particles").c_str());
-        add_param(report,
-                  4,
-                  "Domain decomposition",
-                  "%s [%d total]",
-                  fmt::formatVector(m_metadomain.ndomains_per_dim()).c_str(),
-                  m_metadomain.ndomains());
-        report += "\n";
-        add_category(report, 4, "Fiducial parameters");
-        add_param(report,
-                  4,
-                  "Particles per cell [ppc0]",
-                  "%.1f",
-                  params.template get<real_t>("particles.ppc0"));
-        add_param(report,
-                  4,
-                  "Larmor radius [larmor0]",
-                  "%.3e [%.3f dx0]",
-                  params.template get<real_t>("scales.larmor0"),
-                  params.template get<real_t>("scales.larmor0") /
-                    params.template get<real_t>("scales.dx0"));
-        add_param(report,
-                  4,
-                  "Larmor frequency [omegaB0 * dt]",
-                  "%.3e",
-                  params.template get<real_t>("scales.omegaB0") *
-                    params.template get<real_t>("algorithms.timestep.dt"));
-        add_param(report,
-                  4,
-                  "Skin depth [skindepth0]",
-                  "%.3e [%.3f dx0]",
-                  params.template get<real_t>("scales.skindepth0"),
-                  params.template get<real_t>("scales.skindepth0") /
-                    params.template get<real_t>("scales.dx0"));
-        add_param(report,
-                  4,
-                  "Plasma frequency [omp0 * dt]",
-                  "%.3e",
-                  params.template get<real_t>("algorithms.timestep.dt") /
-                    params.template get<real_t>("scales.skindepth0"));
-        add_param(report,
-                  4,
-                  "Magnetization [sigma0]",
-                  "%.3e",
-                  params.template get<real_t>("scales.sigma0"));
-
-        if (nspec > 0) {
-          report += "\n";
-          add_category(report, 4, "Particles");
-        }
-        for (const auto& species : metadomain.species_params()) {
-          add_subcategory(report,
-                          4,
-                          fmt::format("Species #%d", species.index()).c_str());
-          add_param(report, 6, "Label", "%s", species.label().c_str());
-          add_param(report, 6, "Mass", "%.1f", species.mass());
-          add_param(report, 6, "Charge", "%.1f", species.charge());
-          add_param(report, 6, "Max #", "%d [per domain]", species.maxnpart());
-          add_param(report, 6, "Pusher", "%s", species.pusher().to_string());
-          if (species.mass() != 0.0) {
-            add_param(report, 6, "GCA", "%s", species.use_gca() ? "ON" : "OFF");
-          }
-          add_param(report, 6, "Cooling", "%s", species.cooling().to_string());
-          add_param(report, 6, "# of real-value payloads", "%d", species.npld_r());
-          add_param(report, 6, "# of integer-value payloads", "%d", species.npld_i());
-        }
-        report.pop_back();
-      },
-      m_metadomain,
-      m_params);
-    info::Print(report, colored_stdout);
-
-    report = "\n";
-    CallOnce([&]() {
-      add_category(report, 4, "Domains");
-      report.pop_back();
-    });
-    info::Print(report, colored_stdout);
-
-    for (unsigned int idx { 0 }; idx < m_metadomain.ndomains(); ++idx) {
-      auto is_local = false;
-      for (const auto& lidx : m_metadomain.l_subdomain_indices()) {
-        is_local |= (idx == lidx);
-      }
-      if (is_local) {
-        report             = "";
-        const auto& domain = m_metadomain.subdomain(idx);
-        add_subcategory(report,
-                        4,
-                        fmt::format("Domain #%d", domain.index()).c_str());
-#if defined(MPI_ENABLED)
-        add_param(report, 6, "Rank", "%d", domain.mpi_rank());
-#endif
-        add_param(report,
-                  6,
-                  "Resolution",
-                  "%s",
-                  fmt::formatVector(domain.mesh.n_active()).c_str());
-        add_param(report,
-                  6,
-                  "Extent",
-                  "%s",
-                  fmt::formatVector(domain.mesh.extent()).c_str());
-        add_subcategory(report, 6, "Boundary conditions");
-
-        add_label(
-          report,
-          8 + 2 + 2 * M::Dim,
-          fmt::format("%-10s  %-10s  %-10s", "[flds]", "[prtl]", "[neighbor]").c_str());
-        for (auto& direction : dir::Directions<M::Dim>::all) {
-          const auto flds_bc      = domain.mesh.flds_bc_in(direction);
-          const auto prtl_bc      = domain.mesh.prtl_bc_in(direction);
-          bool       has_sync     = false;
-          auto       neighbor_idx = domain.neighbor_idx_in(direction);
-          if (flds_bc == FldsBC::SYNC || prtl_bc == PrtlBC::SYNC) {
-            has_sync = true;
-          }
-          add_unlabeled_param(report,
-                              8,
-                              direction.to_string().c_str(),
-                              "%-10s  %-10s  %-10s",
-                              flds_bc.to_string(),
-                              prtl_bc.to_string(),
-                              has_sync ? std::to_string(neighbor_idx).c_str()
-                                       : ".");
-        }
-        add_subcategory(report, 6, "Memory footprint");
-        auto flds_footprint         = domain.fields.memory_footprint();
-        auto [flds_size, flds_unit] = bytes_to_human_readable(flds_footprint);
-        add_param(report, 8, "Fields", "%.2f %s", flds_size, flds_unit.c_str());
-        if (domain.species.size() > 0) {
-          add_subcategory(report, 8, "Particles");
-        }
-        for (auto& species : domain.species) {
-          const auto str = fmt::format("Species #%d (%s)",
-                                       species.index(),
-                                       species.label().c_str());
-          auto [size, unit] = bytes_to_human_readable(species.memory_footprint());
-          add_param(report, 10, str.c_str(), "%.2f %s", size, unit.c_str());
-        }
-        report.pop_back();
-        if (idx == m_metadomain.ndomains() - 1) {
-          report += "\n\n";
-        }
-        info::Print(report, colored_stdout, true, false);
-      }
-#if defined(MPI_ENABLED)
-      MPI_Barrier(MPI_COMM_WORLD);
-#endif
-    }
-  }
-
-#define ENGINE_PRINTER(S, M, D)                                                \
-  template void Engine<S, M<D>>::print_report() const;
-
-  NTT_FOREACH_SPECIALIZATION(ENGINE_PRINTER)
-
-#undef ENGINE_PRINTER
-
-} // namespace ntt
diff --git a/src/engines/engine_run.cpp b/src/engines/engine_run.cpp
deleted file mode 100644
index 961e39206..000000000
--- a/src/engines/engine_run.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "enums.h"
-
-#include "arch/traits.h"
-#include "utils/diag.h"
-
-#include "framework/domain/domain.h"
-#include "framework/specialization_registry.h"
-
-#include "engines/engine.hpp"
-
-namespace ntt {
-
-  template <SimEngine::type S, class M>
-  void Engine<S, M>::run() {
-    if constexpr (pgen_is_ok) {
-      init();
-
-      auto timers = timer::Timers {
-        { "FieldSolver",
-         "CurrentFiltering", "CurrentDeposit",
-         "ParticlePusher", "FieldBoundaries",
-         "ParticleBoundaries", "Communications",
-         "Injector", "Custom",
-         "PrtlClear", "Output",
-         "Checkpoint" },
-        []() {
-          Kokkos::fence();
-         },
-        m_params.get<bool>("diagnostics.blocking_timers")
-      };
-      const auto diag_interval = m_params.get<timestep_t>(
-        "diagnostics.interval");
-
-      auto       time_history   = pbar::DurationHistory { 1000 };
-      const auto clear_interval = m_params.template get<timestep_t>(
-        "particles.clear_interval");
-
-      // main algorithm loop
-      while (step < max_steps) {
-        // run the engine-dependent algorithm step
-        m_metadomain.runOnLocalDomains([&timers, this](auto& dom) {
-          step_forward(timers, dom);
-        });
-        // poststep (if defined)
-        if constexpr (
-          traits::has_method<traits::pgen::custom_poststep_t, decltype(m_pgen)>::value) {
-          timers.start("Custom");
-          m_metadomain.runOnLocalDomains([&timers, this](auto& dom) {
-            m_pgen.CustomPostStep(step, time, dom);
-          });
-          timers.stop("Custom");
-        }
-        auto print_prtl_clear = (clear_interval > 0 and
-                                 step % clear_interval == 0 and step > 0);
-
-        // advance time & step
-        time += dt;
-        ++step;
-
-        auto print_output     = false;
-        auto print_checkpoint = false;
-#if defined(OUTPUT_ENABLED)
-        timers.start("Output");
-        if constexpr (
-          traits::has_method<traits::pgen::custom_field_output_t, decltype(m_pgen)>::value) {
-          auto lambda_custom_field_output = [&](const std::string&    name,
-                                                ndfield_t<M::Dim, 6>& buff,
-                                                index_t               idx,
-                                                timestep_t            step,
-                                                simtime_t             time,
-                                                const Domain<S, M>&   dom) {
-            m_pgen.CustomFieldOutput(name, buff, idx, step, time, dom);
-          };
-          print_output &= m_metadomain.Write(m_params,
-                                             step,
-                                             step - 1,
-                                             time,
-                                             time - dt,
-                                             lambda_custom_field_output);
-        } else {
-          print_output &= m_metadomain.Write(m_params, step, step - 1, time, time - dt);
-        }
-        if constexpr (
-          traits::has_method<traits::pgen::custom_stat_t, decltype(m_pgen)>::value) {
-          auto lambda_custom_stat = [&](const std::string&  name,
-                                        timestep_t          step,
-                                        simtime_t           time,
-                                        const Domain<S, M>& dom) -> real_t {
-            return m_pgen.CustomStat(name, step, time, dom);
-          };
-          print_output &= m_metadomain.WriteStats(m_params,
-                                                  step,
-                                                  step - 1,
-                                                  time,
-                                                  time - dt,
-                                                  lambda_custom_stat);
-        } else {
-          print_output &= m_metadomain.WriteStats(m_params,
-                                                  step,
-                                                  step - 1,
-                                                  time,
-                                                  time - dt);
-        }
-        timers.stop("Output");
-
-        timers.start("Checkpoint");
-        print_checkpoint = m_metadomain.WriteCheckpoint(m_params,
-                                                        step,
-                                                        step - 1,
-                                                        time,
-                                                        time - dt);
-        timers.stop("Checkpoint");
-#endif
-
-        // advance time_history
-        time_history.tick();
-        // print timestep report
-        if (diag_interval > 0 and step % diag_interval == 0) {
-          diag::printDiagnostics(
-            step - 1,
-            max_steps,
-            time - dt,
-            dt,
-            timers,
-            time_history,
-            m_metadomain.l_ncells(),
-            m_metadomain.species_labels(),
-            m_metadomain.l_npart_perspec(),
-            m_metadomain.l_maxnpart_perspec(),
-            print_prtl_clear,
-            print_output,
-            print_checkpoint,
-            m_params.get<bool>("diagnostics.colored_stdout"));
-        }
-        timers.resetAll();
-      }
-    }
-  }
-
-#define ENGINE_RUN(S, M, D) template void Engine<S, M<D>>::run();
-
-  NTT_FOREACH_SPECIALIZATION(ENGINE_RUN)
-
-#undef ENGINE_RUN
-
-} // namespace ntt
diff --git a/src/engines/engine_traits.h b/src/engines/engine_traits.h
deleted file mode 100644
index 28a74bea3..000000000
--- a/src/engines/engine_traits.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: BSD-3-Clause
-
-#ifndef ENGINES_ENGINE_TRAITS_H
-#define ENGINES_ENGINE_TRAITS_H
-
-#include "enums.h"
-
-#include "engines/grpic.hpp"
-#include "engines/srpic.hpp"
-
-namespace ntt {
-
-  template <SimEngine::type S>
-  struct EngineSelector;
-
-  template <>
-  struct EngineSelector<SimEngine::SRPIC> {
-    template <class M>
-    using type = SRPICEngine<M>;
-  };
-
-  template <>
-  struct EngineSelector<SimEngine::GRPIC> {
-    template <class M>
-    using type = GRPICEngine<M>;
-  };
-
-} // namespace ntt
-
-#endif // ENGINES_ENGINE_TRAITS_H
diff --git a/src/engines/grpic.hpp b/src/engines/grpic.hpp
index 4d9d89d92..78415e26b 100644
--- a/src/engines/grpic.hpp
+++ b/src/engines/grpic.hpp
@@ -19,10 +19,10 @@
 #include "utils/log.h"
 #include "utils/numeric.h"
 #include "utils/timer.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
 #include "framework/domain/domain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 
 #include "engines/engine.hpp"
 #include "kernels/ampere_gr.hpp"
@@ -66,12 +66,11 @@ namespace ntt {
   };
 
   template <class M>
+    requires traits::engine::IsCompatibleWithGRPICEngine<M, user::PGen>
   class GRPICEngine : public Engine<SimEngine::GRPIC, M> {
     using base_t   = Engine<SimEngine::GRPIC, M>;
     using pgen_t   = user::PGen<SimEngine::GRPIC, M>;
     using domain_t = Domain<SimEngine::GRPIC, M>;
-    // constexprs
-    using base_t::pgen_is_ok;
     // contents
     using base_t::m_metadomain;
     using base_t::m_params;
@@ -638,28 +637,30 @@ namespace ntt {
       }
       if (dim == in::x1) {
         if (g != gr_bc::curr) {
-          Kokkos::parallel_for(
-            "MatchBoundaries",
-            CreateRangePolicy<M::Dim>(range_min, range_max),
-            kernel::bc::MatchBoundaries_kernel<S, decltype(m_pgen.init_flds), M, in::x1>(
-              domain.fields.em,
-              m_pgen.init_flds,
-              domain.mesh.metric,
-              xg_edge,
-              ds,
-              tags,
-              domain.mesh.flds_bc()));
-          Kokkos::parallel_for(
-            "MatchBoundaries",
-            CreateRangePolicy<M::Dim>(range_min, range_max),
-            kernel::bc::MatchBoundaries_kernel<S, decltype(m_pgen.init_flds), M, in::x1>(
-              domain.fields.em0,
-              m_pgen.init_flds,
-              domain.mesh.metric,
-              xg_edge,
-              ds,
-              tags,
-              domain.mesh.flds_bc()));
+          if constexpr (arch::traits::pgen::HasInitFlds<pgen_t>) {
+            Kokkos::parallel_for(
+              "MatchBoundaries",
+              CreateRangePolicy<M::Dim>(range_min, range_max),
+              kernel::bc::MatchBoundaries_kernel<S, decltype(m_pgen.init_flds), M, in::x1>(
+                domain.fields.em,
+                m_pgen.init_flds,
+                domain.mesh.metric,
+                xg_edge,
+                ds,
+                tags,
+                domain.mesh.flds_bc()));
+            Kokkos::parallel_for(
+              "MatchBoundaries",
+              CreateRangePolicy<M::Dim>(range_min, range_max),
+              kernel::bc::MatchBoundaries_kernel<S, decltype(m_pgen.init_flds), M, in::x1>(
+                domain.fields.em0,
+                m_pgen.init_flds,
+                domain.mesh.metric,
+                xg_edge,
+                ds,
+                tags,
+                domain.mesh.flds_bc()));
+          }
         } else {
           Kokkos::parallel_for(
             "AbsorbCurrents",
@@ -696,17 +697,17 @@ namespace ntt {
         Kokkos::parallel_for(
           "OpenBCFields",
           range,
-          kernel::bc::gr::HorizonBoundaries_kernel<M>(domain.fields.em,
-                                                      i1_min,
-                                                      tags,
-                                                      nfilter));
+          kernel::bc::gr::HorizonBoundaries_kernel<M::Dim>(domain.fields.em,
+                                                           i1_min,
+                                                           tags,
+                                                           nfilter));
         Kokkos::parallel_for(
           "OpenBCFields",
           range,
-          kernel::bc::gr::HorizonBoundaries_kernel<M>(domain.fields.em0,
-                                                      i1_min,
-                                                      tags,
-                                                      nfilter));
+          kernel::bc::gr::HorizonBoundaries_kernel<M::Dim>(domain.fields.em0,
+                                                           i1_min,
+                                                           tags,
+                                                           nfilter));
       }
     }
 
@@ -974,19 +975,19 @@ namespace ntt {
     }
 
     void TimeAverageDB(domain_t& domain) {
-      Kokkos::parallel_for("TimeAverageDB",
-                           domain.mesh.rangeActiveCells(),
-                           kernel::gr::TimeAverageDB_kernel<M>(domain.fields.em,
-                                                               domain.fields.em0,
-                                                               domain.mesh.metric));
+      Kokkos::parallel_for(
+        "TimeAverageDB",
+        domain.mesh.rangeActiveCells(),
+        kernel::gr::TimeAverageDB_kernel<M::Dim>(domain.fields.em,
+                                                 domain.fields.em0));
     }
 
     void TimeAverageJ(domain_t& domain) {
-      Kokkos::parallel_for("TimeAverageJ",
-                           domain.mesh.rangeActiveCells(),
-                           kernel::gr::TimeAverageJ_kernel<M>(domain.fields.cur,
-                                                              domain.fields.cur0,
-                                                              domain.mesh.metric));
+      Kokkos::parallel_for(
+        "TimeAverageJ",
+        domain.mesh.rangeActiveCells(),
+        kernel::gr::TimeAverageJ_kernel<M::Dim>(domain.fields.cur,
+                                                domain.fields.cur0));
     }
 
     void CurrentsDeposit(domain_t& domain) {
@@ -1081,36 +1082,40 @@ namespace ntt {
           "algorithms.gr.pusher_eps");
         const auto niter = m_params.template get<unsigned short>(
           "algorithms.gr.pusher_niter");
-        // clang-format off
-        if (species.pusher() == PrtlPusher::PHOTON) {
-        auto range_policy = Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace, kernel::gr::Massless_t>(
-          0,
-          species.npart());
+        if (species.pusher() == ParticlePusher::PHOTON) {
+          auto range_policy =
+            Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace, kernel::gr::Massless_t>(
+              0,
+              species.npart());
 
-        Kokkos::parallel_for(
-          "ParticlePusher",
-          range_policy,
-          kernel::gr::Pusher_kernel<M>(
-              domain.fields.em,
-              domain.fields.em0,
-              species.i1,        species.i2,       species.i3,
-              species.i1_prev,   species.i2_prev,  species.i3_prev,
-              species.dx1,       species.dx2,      species.dx3,
-              species.dx1_prev,  species.dx2_prev, species.dx3_prev,
-              species.ux1,       species.ux2,      species.ux3,
-              species.phi,       species.tag,
-              domain.mesh.metric,
-              coeff, dt,
-              domain.mesh.n_active(in::x1),
-              domain.mesh.n_active(in::x2),
-              domain.mesh.n_active(in::x3),
-              eps, niter,
-              domain.mesh.prtl_bc()
-          ));
-        } else if (species.pusher() == PrtlPusher::BORIS) {
-          auto range_policy = Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace, kernel::gr::Massive_t>(
-          0,
-          species.npart());
+          // clang-format off
+          Kokkos::parallel_for(
+            "ParticlePusher",
+            range_policy,
+            kernel::gr::Pusher_kernel<M>(
+                domain.fields.em,
+                domain.fields.em0,
+                species.i1,        species.i2,       species.i3,
+                species.i1_prev,   species.i2_prev,  species.i3_prev,
+                species.dx1,       species.dx2,      species.dx3,
+                species.dx1_prev,  species.dx2_prev, species.dx3_prev,
+                species.ux1,       species.ux2,      species.ux3,
+                species.phi,       species.tag,
+                domain.mesh.metric,
+                coeff, dt,
+                domain.mesh.n_active(in::x1),
+                domain.mesh.n_active(in::x2),
+                domain.mesh.n_active(in::x3),
+                eps, niter,
+                domain.mesh.prtl_bc()
+            ));
+          // clang-format on
+        } else if (species.pusher() == ParticlePusher::BORIS) {
+          auto range_policy =
+            Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace, kernel::gr::Massive_t>(
+              0,
+              species.npart());
+          // clang-format off
           Kokkos::parallel_for(
             "ParticlePusher",
             range_policy,
@@ -1131,12 +1136,12 @@ namespace ntt {
                 eps, niter,
                 domain.mesh.prtl_bc()
           ));
-        } else if (species.pusher() == PrtlPusher::NONE) {
+          // clang-format on
+        } else if (species.pusher() == ParticlePusher::NONE) {
           // do nothing
         } else {
           raise::Error("not implemented", HERE);
         }
-        // clang-format on
       }
     }
   };
diff --git a/src/engines/reporter.cpp b/src/engines/reporter.cpp
new file mode 100644
index 000000000..1954596fe
--- /dev/null
+++ b/src/engines/reporter.cpp
@@ -0,0 +1,155 @@
+#include "engines/reporter.h"
+
+#include "enums.h"
+
+#include "utils/reporter.h"
+
+#include "framework/parameters/parameters.h"
+
+#include <string>
+#include <vector>
+
+namespace ntt {
+
+  auto ReportSimulationConfig(const SimulationParams&          params,
+                              const std::string&               pgen,
+                              SimEngine                        S,
+                              Metric                           M,
+                              real_t                           dt,
+                              simtime_t                        runtime,
+                              timestep_t                       max_steps,
+                              const std::vector<unsigned int>& ndomains_per_dim,
+                              unsigned int ndomains) -> std::string {
+    std::string report = "";
+    /*
+     * Simulation configs
+     */
+    reporter::AddCategory(report, 4, "Configuration");
+    reporter::AddParam(report,
+                       4,
+                       "Name",
+                       "%s",
+                       params.template get<std::string>("simulation.name").c_str());
+    reporter::AddParam(report, 4, "Problem generator", "%s", pgen.c_str());
+    reporter::AddParam(report, 4, "Engine", "%s", S.to_string());
+    reporter::AddParam(report, 4, "Metric", "%s", M.to_string());
+#if SHAPE_ORDER == 0
+    reporter::AddParam(report, 4, "Deposit", "%s", "zigzag");
+#else
+    reporter::AddParam(report, 4, "Deposit", "%s", "esirkepov");
+    reporter::AddParam(report, 4, "Interpolation order", "%i", SHAPE_ORDER);
+#endif
+    reporter::AddParam(report, 4, "Timestep [dt]", "%.3e", dt);
+    reporter::AddParam(report, 4, "Runtime", "%.3e [%d steps]", runtime, max_steps);
+    report += "\n";
+    reporter::AddCategory(report, 4, "Global domain");
+    reporter::AddParam(
+      report,
+      4,
+      "Resolution",
+      "%s",
+      params.template stringize<ncells_t>("grid.resolution").c_str());
+    reporter::AddParam(report,
+                       4,
+                       "Extent",
+                       "%s",
+                       params.template stringize<real_t>("grid.extent").c_str());
+    reporter::AddParam(report,
+                       4,
+                       "Fiducial cell size [dx0]",
+                       "%.3e",
+                       params.template get<real_t>("scales.dx0"));
+    reporter::AddSubcategory(report, 4, "Boundary conditions");
+    reporter::AddParam(
+      report,
+      6,
+      "Fields",
+      "%s",
+      params.template stringize<FldsBC>("grid.boundaries.fields").c_str());
+    reporter::AddParam(
+      report,
+      6,
+      "Particles",
+      "%s",
+      params.template stringize<PrtlBC>("grid.boundaries.particles").c_str());
+    reporter::AddParam(report,
+                       4,
+                       "Domain decomposition",
+                       "%s [%d total]",
+                       fmt::formatVector(ndomains_per_dim).c_str(),
+                       ndomains);
+    report += "\n";
+    reporter::AddCategory(report, 4, "Nominal parameters");
+    reporter::AddParam(report,
+                       4,
+                       "Particles per cell [ppc0]",
+                       "%.1f",
+                       params.template get<real_t>("particles.ppc0"));
+    reporter::AddParam(report,
+                       4,
+                       "Larmor radius [larmor0]",
+                       "%.3e [%.3f dx0]",
+                       params.template get<real_t>("scales.larmor0"),
+                       params.template get<real_t>("scales.larmor0") /
+                         params.template get<real_t>("scales.dx0"));
+    reporter::AddParam(report,
+                       4,
+                       "Larmor frequency [omegaB0 * dt]",
+                       "%.3e",
+                       params.template get<real_t>("scales.omegaB0") *
+                         params.template get<real_t>("algorithms.timestep.dt"));
+    reporter::AddParam(report,
+                       4,
+                       "Skin depth [skindepth0]",
+                       "%.3e [%.3f dx0]",
+                       params.template get<real_t>("scales.skindepth0"),
+                       params.template get<real_t>("scales.skindepth0") /
+                         params.template get<real_t>("scales.dx0"));
+    reporter::AddParam(report,
+                       4,
+                       "Plasma frequency [omp0 * dt]",
+                       "%.3e",
+                       params.template get<real_t>("algorithms.timestep.dt") /
+                         params.template get<real_t>("scales.skindepth0"));
+    reporter::AddParam(report,
+                       4,
+                       "Magnetization [sigma0]",
+                       "%.3e",
+                       params.template get<real_t>("scales.sigma0"));
+
+    if (params.contains("radiation.emission.compton.photon_species")) {
+      reporter::AddCategory(report, 4, "- Compton emission");
+      reporter::AddParam(report,
+                         6,
+                         "Nominal probability",
+                         "%.3e",
+                         params.template get<real_t>(
+                           "radiation.emission.compton.nominal_probability"));
+      reporter::AddParam(report,
+                         6,
+                         "Nominal photon energy",
+                         "%.3e",
+                         params.template get<real_t>(
+                           "radiation.emission.compton.nominal_photon_energy"));
+    }
+    if (params.contains("radiation.emission.synchrotron.photon_species")) {
+      reporter::AddCategory(report, 4, "- Synchrotron emission");
+      reporter::AddParam(
+        report,
+        6,
+        "Nominal probability",
+        "%.3e",
+        params.template get<real_t>(
+          "radiation.emission.synchrotron.nominal_probability"));
+      reporter::AddParam(
+        report,
+        6,
+        "Nominal photon energy",
+        "%.3e",
+        params.template get<real_t>(
+          "radiation.emission.synchrotron.nominal_photon_energy"));
+    }
+    return report;
+  }
+
+} // namespace ntt
diff --git a/src/engines/reporter.h b/src/engines/reporter.h
new file mode 100644
index 000000000..3fd4c4b7a
--- /dev/null
+++ b/src/engines/reporter.h
@@ -0,0 +1,25 @@
+#ifndef ENGINES_REPORTER_H
+#define ENGINES_REPORTER_H
+
+#include "enums.h"
+
+#include "framework/parameters/parameters.h"
+
+#include <string>
+#include <vector>
+
+namespace ntt {
+
+  auto ReportSimulationConfig(const SimulationParams&,
+                              const std::string&,
+                              SimEngine,
+                              Metric,
+                              real_t,
+                              simtime_t,
+                              timestep_t,
+                              const std::vector<unsigned int>&,
+                              unsigned int) -> std::string;
+
+} // namespace ntt
+
+#endif // ENGINES_REPORTER_H
diff --git a/src/engines/srpic.hpp b/src/engines/srpic.hpp
deleted file mode 100644
index 0dad75e91..000000000
--- a/src/engines/srpic.hpp
+++ /dev/null
@@ -1,1569 +0,0 @@
-/**
- * @file engines/srpic.hpp
- * @brief Simulation engien class which specialized on SRPIC
- * @implements
- *   - ntt::SRPICEngine<> : ntt::Engine<>
- * @cpp:
- *   - srpic.cpp
- * @namespaces:
- *   - ntt::
- * @macros:
- */
-
-#ifndef ENGINES_SRPIC_SRPIC_H
-#define ENGINES_SRPIC_SRPIC_H
-
-#include "enums.h"
-#include "global.h"
-
-#include "arch/kokkos_aliases.h"
-#include "arch/traits.h"
-#include "utils/log.h"
-#include "utils/numeric.h"
-#include "utils/timer.h"
-#include "utils/toml.h"
-
-#include "archetypes/energy_dist.h"
-#include "archetypes/particle_injector.h"
-#include "archetypes/spatial_dist.h"
-#include "framework/domain/domain.h"
-#include "framework/parameters.h"
-
-#include "engines/engine.hpp"
-#include "kernels/ampere_mink.hpp"
-#include "kernels/ampere_sr.hpp"
-#include "kernels/currents_deposit.hpp"
-#include "kernels/digital_filter.hpp"
-#include "kernels/faraday_mink.hpp"
-#include "kernels/faraday_sr.hpp"
-#include "kernels/fields_bcs.hpp"
-#include "kernels/particle_moments.hpp"
-#include "kernels/particle_pusher_sr.hpp"
-#include "pgen.hpp"
-
-#include <Kokkos_Core.hpp>
-#include <Kokkos_ScatterView.hpp>
-
-#include <utility>
-
-namespace ntt {
-
-  template <class M>
-  class SRPICEngine : public Engine<SimEngine::SRPIC, M> {
-
-    using base_t   = Engine<SimEngine::SRPIC, M>;
-    using pgen_t   = user::PGen<SimEngine::SRPIC, M>;
-    using domain_t = Domain<SimEngine::SRPIC, M>;
-    // constexprs
-    using base_t::pgen_is_ok;
-    // contents
-    using base_t::m_metadomain;
-    using base_t::m_params;
-    using base_t::m_pgen;
-    // methods
-    using base_t::init;
-    // variables
-    using base_t::dt;
-    using base_t::max_steps;
-    using base_t::runtime;
-    using base_t::step;
-    using base_t::time;
-
-  public:
-    static constexpr auto S { SimEngine::SRPIC };
-
-    SRPICEngine(const SimulationParams& params) : base_t { params } {}
-
-    ~SRPICEngine() = default;
-
-    void step_forward(timer::Timers& timers, domain_t& dom) override {
-      const auto fieldsolver_enabled = m_params.template get<bool>(
-        "algorithms.fieldsolver.enable");
-      const auto deposit_enabled = m_params.template get<bool>(
-        "algorithms.deposit.enable");
-      const auto clear_interval = m_params.template get<std::size_t>(
-        "particles.clear_interval");
-
-      if (step == 0) {
-        // communicate fields and apply BCs on the first timestep
-        m_metadomain.CommunicateFields(dom, Comm::B | Comm::E);
-        FieldBoundaries(dom, BC::B | BC::E);
-        ParticleInjector(dom);
-      }
-
-      if (fieldsolver_enabled) {
-        timers.start("FieldSolver");
-        Faraday(dom, HALF);
-        timers.stop("FieldSolver");
-
-        timers.start("Communications");
-        m_metadomain.CommunicateFields(dom, Comm::B);
-        timers.stop("Communications");
-
-        timers.start("FieldBoundaries");
-        FieldBoundaries(dom, BC::B);
-        timers.stop("FieldBoundaries");
-        Kokkos::fence();
-      }
-
-      {
-        timers.start("ParticlePusher");
-        ParticlePush(dom);
-        timers.stop("ParticlePusher");
-
-        if (deposit_enabled) {
-          timers.start("CurrentDeposit");
-          Kokkos::deep_copy(dom.fields.cur, ZERO);
-          CurrentsDeposit(dom);
-          timers.stop("CurrentDeposit");
-
-          timers.start("Communications");
-          m_metadomain.SynchronizeFields(dom, Comm::J);
-          m_metadomain.CommunicateFields(dom, Comm::J);
-          timers.stop("Communications");
-
-          timers.start("CurrentFiltering");
-          CurrentsFilter(dom);
-          timers.stop("CurrentFiltering");
-        }
-
-        timers.start("Communications");
-        m_metadomain.CommunicateParticles(dom);
-        timers.stop("Communications");
-      }
-
-      if (fieldsolver_enabled) {
-        timers.start("FieldSolver");
-        Faraday(dom, HALF);
-        timers.stop("FieldSolver");
-
-        timers.start("Communications");
-        m_metadomain.CommunicateFields(dom, Comm::B);
-        timers.stop("Communications");
-
-        timers.start("FieldBoundaries");
-        FieldBoundaries(dom, BC::B);
-        timers.stop("FieldBoundaries");
-
-        timers.start("FieldSolver");
-        Ampere(dom, ONE);
-        timers.stop("FieldSolver");
-
-        if (deposit_enabled) {
-          timers.start("FieldSolver");
-          CurrentsAmpere(dom);
-          timers.stop("FieldSolver");
-        }
-
-        timers.start("Communications");
-        m_metadomain.CommunicateFields(dom, Comm::E | Comm::J);
-        timers.stop("Communications");
-
-        timers.start("FieldBoundaries");
-        FieldBoundaries(dom, BC::E);
-        timers.stop("FieldBoundaries");
-      }
-
-      {
-        timers.start("Injector");
-        ParticleInjector(dom);
-        timers.stop("Injector");
-      }
-
-      if (clear_interval > 0 and step % clear_interval == 0 and step > 0) {
-        timers.start("PrtlClear");
-        m_metadomain.RemoveDeadParticles(dom);
-        timers.stop("PrtlClear");
-      }
-    }
-
-    /* algorithm substeps --------------------------------------------------- */
-    void Faraday(domain_t& domain, real_t fraction = ONE) {
-      logger::Checkpoint("Launching Faraday kernel", HERE);
-      const auto dT = fraction *
-                      m_params.template get<real_t>(
-                        "algorithms.timestep.correction") *
-                      dt;
-      if constexpr (M::CoordType == Coord::Cart) {
-        // minkowski case
-        const auto dx = math::sqrt(domain.mesh.metric.template h_<1, 1>({}));
-        const auto deltax = m_params.template get<real_t>(
-          "algorithms.fieldsolver.delta_x");
-        const auto deltay = m_params.template get<real_t>(
-          "algorithms.fieldsolver.delta_y");
-        const auto betaxy = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_xy");
-        const auto betayx = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_yx");
-        const auto deltaz = m_params.template get<real_t>(
-          "algorithms.fieldsolver.delta_z");
-        const auto betaxz = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_xz");
-        const auto betazx = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_zx");
-        const auto betayz = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_yz");
-        const auto betazy = m_params.template get<real_t>(
-          "algorithms.fieldsolver.beta_zy");
-        real_t coeff1, coeff2;
-        if constexpr (M::Dim == Dim::_2D) {
-          coeff1 = dT / SQR(dx);
-          coeff2 = dT;
-        } else {
-          coeff1 = dT / dx;
-          coeff2 = ZERO;
-        }
-        Kokkos::parallel_for("Faraday",
-                             domain.mesh.rangeActiveCells(),
-                             kernel::mink::Faraday_kernel<M::Dim>(domain.fields.em,
-                                                                  coeff1,
-                                                                  coeff2,
-                                                                  deltax,
-                                                                  deltay,
-                                                                  betaxy,
-                                                                  betayx,
-                                                                  deltaz,
-                                                                  betaxz,
-                                                                  betazx,
-                                                                  betayz,
-                                                                  betazy));
-      } else {
-        Kokkos::parallel_for("Faraday",
-                             domain.mesh.rangeActiveCells(),
-                             kernel::sr::Faraday_kernel<M>(domain.fields.em,
-                                                           domain.mesh.metric,
-                                                           dT,
-                                                           domain.mesh.flds_bc()));
-      }
-    }
-
-    void Ampere(domain_t& domain, real_t fraction = ONE) {
-      logger::Checkpoint("Launching Ampere kernel", HERE);
-      const auto dT = fraction *
-                      m_params.template get<real_t>(
-                        "algorithms.timestep.correction") *
-                      dt;
-      auto range = range_with_axis_BCs(domain);
-      if constexpr (M::CoordType == Coord::Cart) {
-        // minkowski case
-        const auto dx = math::sqrt(domain.mesh.metric.template h_<1, 1>({}));
-        real_t     coeff1, coeff2;
-        if constexpr (M::Dim == Dim::_2D) {
-          coeff1 = dT / SQR(dx);
-          coeff2 = dT;
-        } else {
-          coeff1 = dT / dx;
-          coeff2 = ZERO;
-        }
-
-        Kokkos::parallel_for(
-          "Ampere",
-          range,
-          kernel::mink::Ampere_kernel<M::Dim>(domain.fields.em, coeff1, coeff2));
-      } else {
-        const auto ni2 = domain.mesh.n_active(in::x2);
-        Kokkos::parallel_for("Ampere",
-                             range,
-                             kernel::sr::Ampere_kernel<M>(domain.fields.em,
-                                                          domain.mesh.metric,
-                                                          dT,
-                                                          ni2,
-                                                          domain.mesh.flds_bc()));
-      }
-    }
-
-    void ParticlePush(domain_t& domain) {
-      real_t gx1 { ZERO }, gx2 { ZERO }, gx3 { ZERO }, ds { ZERO };
-      real_t x_surf { ZERO };
-      bool   has_atmosphere = false;
-      for (auto& direction : dir::Directions<M::Dim>::orth) {
-        if (m_metadomain.mesh().prtl_bc_in(direction) == PrtlBC::ATMOSPHERE) {
-          raise::ErrorIf(has_atmosphere,
-                         "Only one direction is allowed to have atm boundaries",
-                         HERE);
-          has_atmosphere = true;
-          const auto g   = m_params.template get<real_t>(
-            "grid.boundaries.atmosphere.g");
-          ds = m_params.template get<real_t>("grid.boundaries.atmosphere.ds");
-          const auto [sign, dim, xg_min, xg_max] = get_atm_extent(direction);
-          if (dim == in::x1) {
-            gx1 = sign > 0 ? g : -g;
-            gx2 = ZERO;
-            gx3 = ZERO;
-          } else if (dim == in::x2) {
-            gx1 = ZERO;
-            gx2 = sign > 0 ? g : -g;
-            gx3 = ZERO;
-          } else if (dim == in::x3) {
-            gx1 = ZERO;
-            gx2 = ZERO;
-            gx3 = sign > 0 ? g : -g;
-          } else {
-            raise::Error("Invalid dimension", HERE);
-          }
-          if (sign > 0) {
-            x_surf = xg_min;
-          } else {
-            x_surf = xg_max;
-          }
-        }
-      }
-      for (auto& species : domain.species) {
-        if ((species.pusher() == PrtlPusher::NONE) or (species.npart() == 0)) {
-          continue;
-        }
-        species.set_unsorted();
-        logger::Checkpoint(
-          fmt::format("Launching particle pusher kernel for %d [%s] : %lu",
-                      species.index(),
-                      species.label().c_str(),
-                      species.npart()),
-          HERE);
-        const auto q_ovr_m = species.mass() > ZERO
-                               ? species.charge() / species.mass()
-                               : ZERO;
-        //  coeff = q / m (dt / 2) omegaB0
-        const auto coeff   = q_ovr_m * HALF * dt *
-                           m_params.template get<real_t>("scales.omegaB0");
-        PrtlPusher::type pusher;
-        if (species.pusher() == PrtlPusher::PHOTON) {
-          pusher = PrtlPusher::PHOTON;
-        } else if (species.pusher() == PrtlPusher::BORIS) {
-          pusher = PrtlPusher::BORIS;
-        } else if (species.pusher() == PrtlPusher::VAY) {
-          pusher = PrtlPusher::VAY;
-        } else {
-          raise::Fatal("Invalid particle pusher", HERE);
-        }
-        const auto cooling = species.cooling();
-
-        // coefficients to be forwarded to the dispatcher
-        // gca
-        const auto has_gca         = species.use_gca();
-        const auto gca_larmor_max  = has_gca ? m_params.template get<real_t>(
-                                                "algorithms.gca.larmor_max")
-                                             : ZERO;
-        const auto gca_eovrb_max   = has_gca ? m_params.template get<real_t>(
-                                               "algorithms.gca.e_ovr_b_max")
-                                             : ZERO;
-        // cooling
-        const auto has_synchrotron = (cooling == Cooling::SYNCHROTRON);
-        const auto has_compton     = (cooling == Cooling::COMPTON);
-        const auto sync_grad       = has_synchrotron
-                                       ? m_params.template get<real_t>(
-                                     "algorithms.synchrotron.gamma_rad")
-                                       : ZERO;
-        const auto sync_coeff      = has_synchrotron
-                                       ? (real_t)(0.1) * dt *
-                                      m_params.template get<real_t>(
-                                        "scales.omegaB0") /
-                                      (SQR(sync_grad) * species.mass())
-                                       : ZERO;
-        const auto comp_grad    = has_compton ? m_params.template get<real_t>(
-                                               "algorithms.compton.gamma_rad")
-                                              : ZERO;
-        const auto comp_coeff   = has_compton ? (real_t)(0.1) * dt *
-                                                m_params.template get<real_t>(
-                                                  "scales.omegaB0") /
-                                                (SQR(comp_grad) * species.mass())
-                                              : ZERO;
-        // toggle to indicate whether pgen defines the external force
-        bool       has_extforce = false;
-        if constexpr (traits::has_member<traits::pgen::ext_force_t, pgen_t>::value) {
-          has_extforce = true;
-          // toggle to indicate whether the ext force applies to current species
-          if (traits::has_member<traits::species_t, decltype(pgen_t::ext_force)>::value) {
-            has_extforce &= std::find(m_pgen.ext_force.species.begin(),
-                                      m_pgen.ext_force.species.end(),
-                                      species.index()) !=
-                            m_pgen.ext_force.species.end();
-          }
-        }
-
-        kernel::sr::CoolingTags cooling_tags = 0;
-        if (cooling == Cooling::SYNCHROTRON) {
-          cooling_tags = kernel::sr::Cooling::Synchrotron;
-        }
-        if (cooling == Cooling::COMPTON) {
-          cooling_tags = kernel::sr::Cooling::Compton;
-        }
-        // clang-format off
-        if (not has_atmosphere and not has_extforce) {
-          Kokkos::parallel_for(
-            "ParticlePusher",
-            species.rangeActiveParticles(),
-            kernel::sr::Pusher_kernel<M>(
-                pusher, has_gca, false,
-                cooling_tags,
-                domain.fields.em,
-                species.index(),
-                species.i1,        species.i2,       species.i3,
-                species.i1_prev,   species.i2_prev,  species.i3_prev,
-                species.dx1,       species.dx2,      species.dx3,
-                species.dx1_prev,  species.dx2_prev, species.dx3_prev,
-                species.ux1,       species.ux2,      species.ux3,
-                species.phi,       species.tag,
-                domain.mesh.metric,
-                time, coeff, dt,
-                domain.mesh.n_active(in::x1),
-                domain.mesh.n_active(in::x2),
-                domain.mesh.n_active(in::x3),
-                domain.mesh.prtl_bc(),
-                gca_larmor_max, gca_eovrb_max, sync_coeff, comp_coeff
-            ));
-        } else if (has_atmosphere and not has_extforce) {
-          const auto force =
-            kernel::sr::Force<M::PrtlDim, M::CoordType, kernel::sr::NoForce_t, true> {
-              {gx1, gx2, gx3},
-              x_surf,
-              ds
-            };
-          Kokkos::parallel_for(
-            "ParticlePusher",
-            species.rangeActiveParticles(),
-            kernel::sr::Pusher_kernel<M, decltype(force)>(
-                pusher, has_gca, false,
-                cooling_tags,
-                domain.fields.em,
-                species.index(),
-                species.i1,        species.i2,       species.i3,
-                species.i1_prev,   species.i2_prev,  species.i3_prev,
-                species.dx1,       species.dx2,      species.dx3,
-                species.dx1_prev,  species.dx2_prev, species.dx3_prev,
-                species.ux1,       species.ux2,      species.ux3,
-                species.phi,       species.tag,
-                domain.mesh.metric,
-                force,
-                time, coeff, dt,
-                domain.mesh.n_active(in::x1),
-                domain.mesh.n_active(in::x2),
-                domain.mesh.n_active(in::x3),
-                domain.mesh.prtl_bc(),
-                gca_larmor_max, gca_eovrb_max, sync_coeff, comp_coeff
-            ));
-        } else if (not has_atmosphere and has_extforce) {
-          if constexpr (traits::has_member<traits::pgen::ext_force_t, pgen_t>::value) {
-            const auto force =
-              kernel::sr::Force<M::PrtlDim, M::CoordType, decltype(m_pgen.ext_force), false> {
-                m_pgen.ext_force
-              };
-            Kokkos::parallel_for(
-              "ParticlePusher",
-              species.rangeActiveParticles(),
-              kernel::sr::Pusher_kernel<M, decltype(force)>(
-                  pusher, has_gca, true,
-                  cooling_tags,
-                  domain.fields.em,
-                  species.index(),
-                  species.i1,        species.i2,       species.i3,
-                  species.i1_prev,   species.i2_prev,  species.i3_prev,
-                  species.dx1,       species.dx2,      species.dx3,
-                  species.dx1_prev,  species.dx2_prev, species.dx3_prev,
-                  species.ux1,       species.ux2,      species.ux3,
-                  species.phi,       species.tag,
-                  domain.mesh.metric,
-                  force,
-                  time, coeff, dt,
-                  domain.mesh.n_active(in::x1),
-                  domain.mesh.n_active(in::x2),
-                  domain.mesh.n_active(in::x3),
-                  domain.mesh.prtl_bc(),
-                  gca_larmor_max, gca_eovrb_max, sync_coeff, comp_coeff
-              ));
-          } else {
-            raise::Error("External force not implemented", HERE);
-          }
-        } else { // has_atmosphere and has_extforce
-          if constexpr (traits::has_member<traits::pgen::ext_force_t, pgen_t>::value) {
-            const auto force =
-              kernel::sr::Force<M::PrtlDim, M::CoordType, decltype(m_pgen.ext_force), true> {
-                m_pgen.ext_force, {gx1, gx2, gx3}, x_surf, ds
-              };
-            Kokkos::parallel_for(
-              "ParticlePusher",
-              species.rangeActiveParticles(),
-              kernel::sr::Pusher_kernel<M, decltype(force)>(
-                  pusher, has_gca, true,
-                  cooling_tags,
-                  domain.fields.em,
-                  species.index(),
-                  species.i1,        species.i2,       species.i3,
-                  species.i1_prev,   species.i2_prev,  species.i3_prev,
-                  species.dx1,       species.dx2,      species.dx3,
-                  species.dx1_prev,  species.dx2_prev, species.dx3_prev,
-                  species.ux1,       species.ux2,      species.ux3,
-                  species.phi,       species.tag,
-                  domain.mesh.metric,
-                  force,
-                  time, coeff, dt,
-                  domain.mesh.n_active(in::x1),
-                  domain.mesh.n_active(in::x2),
-                  domain.mesh.n_active(in::x3),
-                  domain.mesh.prtl_bc(),
-                  gca_larmor_max, gca_eovrb_max, sync_coeff, comp_coeff
-              ));
-          } else {
-            raise::Error("External force not implemented", HERE);
-          }          
-        }
-        // clang-format on
-      }
-    }
-
-    void ParticleInjector(domain_t& domain, InjTags tags = Inj::None) {
-      for (auto& direction : dir::Directions<M::Dim>::orth) {
-        if (m_metadomain.mesh().prtl_bc_in(direction) == PrtlBC::ATMOSPHERE) {
-          AtmosphereParticlesIn(direction, domain, tags);
-        }
-      }
-    }
-
-    template <unsigned short O>
-    void deposit_with(const Particles<M::Dim, M::CoordType>& species,
-                      const M&                               metric,
-                      const scatter_ndfield_t<M::Dim, 3>&    scatter_cur,
-                      real_t                                 dt) {
-      // clang-format off
-      Kokkos::parallel_for("CurrentsDeposit",
-                          species.rangeActiveParticles(),
-                          kernel::DepositCurrents_kernel<SimEngine::SRPIC, M, O>(
-                            scatter_cur,
-                            species.i1, species.i2, species.i3,
-                            species.i1_prev, species.i2_prev, species.i3_prev,
-                            species.dx1, species.dx2, species.dx3,
-                            species.dx1_prev, species.dx2_prev, species.dx3_prev,
-                            species.ux1, species.ux2, species.ux3,
-                            species.phi, species.weight, species.tag,
-                            metric, (real_t)(species.charge()), dt));
-      // clang-format on
-    }
-
-    void CurrentsDeposit(domain_t& domain) {
-      auto scatter_cur = Kokkos::Experimental::create_scatter_view(
-        domain.fields.cur);
-      auto shape_order = m_params.template get<int>("algorithms.deposit.order");
-      for (auto& species : domain.species) {
-        if ((species.pusher() == PrtlPusher::NONE) or (species.npart() == 0) or
-            cmp::AlmostZero_host(species.charge())) {
-          continue;
-        }
-        logger::Checkpoint(
-          fmt::format("Launching currents deposit kernel for %d [%s] : %lu %f",
-                      species.index(),
-                      species.label().c_str(),
-                      species.npart(),
-                      (double)species.charge()),
-          HERE);
-
-        deposit_with<SHAPE_ORDER>(species, domain.mesh.metric, scatter_cur, dt);
-      }
-      Kokkos::Experimental::contribute(domain.fields.cur, scatter_cur);
-    }
-
-    void CurrentsAmpere(domain_t& domain) {
-      logger::Checkpoint("Launching Ampere kernel for adding currents", HERE);
-      const auto q0 = m_params.template get<real_t>("scales.q0");
-      const auto n0 = m_params.template get<real_t>("scales.n0");
-      const auto B0 = m_params.template get<real_t>("scales.B0");
-      if constexpr (M::CoordType == Coord::Cart) {
-        // minkowski case
-        const auto V0    = m_params.template get<real_t>("scales.V0");
-        const auto ppc0  = m_params.template get<real_t>("particles.ppc0");
-        const auto coeff = -dt * q0 / (B0 * V0);
-        if constexpr (
-          traits::has_member<traits::pgen::ext_current_t, pgen_t>::value) {
-          const std::vector<real_t> xmin { domain.mesh.extent(in::x1).first,
-                                           domain.mesh.extent(in::x2).first,
-                                           domain.mesh.extent(in::x3).first };
-          const auto                ext_current = m_pgen.ext_current;
-          const auto dx = domain.mesh.metric.template sqrt_h_<1, 1>({});
-          // clang-format off
-          Kokkos::parallel_for(
-            "Ampere",
-            domain.mesh.rangeActiveCells(),
-            kernel::mink::CurrentsAmpere_kernel<M::Dim, decltype(ext_current)>(
-              domain.fields.em, domain.fields.cur,
-              coeff, ppc0, ext_current, xmin, dx));
-          // clang-format on
-        } else {
-          Kokkos::parallel_for(
-            "Ampere",
-            domain.mesh.rangeActiveCells(),
-            kernel::mink::CurrentsAmpere_kernel<M::Dim>(domain.fields.em,
-                                                        domain.fields.cur,
-                                                        coeff,
-                                                        ppc0));
-        }
-      } else {
-        // non-minkowski
-        const auto coeff = -dt * q0 * n0 / B0;
-        auto       range = range_with_axis_BCs(domain);
-        const auto ni2   = domain.mesh.n_active(in::x2);
-        Kokkos::parallel_for(
-          "Ampere",
-          range,
-          kernel::sr::CurrentsAmpere_kernel<M>(domain.fields.em,
-                                               domain.fields.cur,
-                                               domain.mesh.metric,
-                                               coeff,
-                                               ONE / n0,
-                                               ni2,
-                                               domain.mesh.flds_bc()));
-      }
-    }
-
-    void CurrentsFilter(domain_t& domain) {
-      logger::Checkpoint("Launching currents filtering kernels", HERE);
-      auto       range   = range_with_axis_BCs(domain);
-      const auto nfilter = m_params.template get<unsigned short>(
-        "algorithms.current_filters");
-      tuple_t<ncells_t, M::Dim> size;
-      if constexpr (M::Dim == Dim::_1D || M::Dim == Dim::_2D || M::Dim == Dim::_3D) {
-        size[0] = domain.mesh.n_active(in::x1);
-      }
-      if constexpr (M::Dim == Dim::_2D || M::Dim == Dim::_3D) {
-        size[1] = domain.mesh.n_active(in::x2);
-      }
-      if constexpr (M::Dim == Dim::_3D) {
-        size[2] = domain.mesh.n_active(in::x3);
-      }
-      // !TODO: this needs to be done more efficiently
-      for (auto i { 0u }; i < nfilter; ++i) {
-        Kokkos::deep_copy(domain.fields.buff, domain.fields.cur);
-        Kokkos::parallel_for("CurrentsFilter",
-                             range,
-                             kernel::DigitalFilter_kernel<M::Dim, M::CoordType>(
-                               domain.fields.cur,
-                               domain.fields.buff,
-                               size,
-                               domain.mesh.flds_bc()));
-        m_metadomain.CommunicateFields(domain, Comm::J);
-      }
-    }
-
-    void FieldBoundaries(domain_t& domain, BCTags tags) {
-      for (auto& direction : dir::Directions<M::Dim>::orth) {
-        if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::MATCH) {
-          MatchFieldsIn(direction, domain, tags);
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::AXIS) {
-          if (domain.mesh.flds_bc_in(direction) == FldsBC::AXIS) {
-            AxisFieldsIn(direction, domain, tags);
-          }
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::ATMOSPHERE) {
-          AtmosphereFieldsIn(direction, domain, tags);
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::FIXED) {
-          if (domain.mesh.flds_bc_in(direction) == FldsBC::FIXED) {
-            FixedFieldsIn(direction, domain, tags);
-          }
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::CONDUCTOR) {
-          if (domain.mesh.flds_bc_in(direction) == FldsBC::CONDUCTOR) {
-            PerfectConductorFieldsIn(direction, domain, tags);
-          }
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::CUSTOM) {
-          if (domain.mesh.flds_bc_in(direction) == FldsBC::CUSTOM) {
-            CustomFieldsIn(direction, domain, tags);
-          }
-        } else if (m_metadomain.mesh().flds_bc_in(direction) == FldsBC::HORIZON) {
-          raise::Error("HORIZON BCs only applicable for GR", HERE);
-        }
-      } // loop over directions
-    }
-
-    void MatchFieldsIn(dir::direction_t<M::Dim> direction,
-                       domain_t&                domain,
-                       BCTags                   tags) {
-      /**
-       * matching boundaries
-       */
-      const auto ds_array = m_params.template get<boundaries_t<real_t>>(
-        "grid.boundaries.match.ds");
-      const auto dim = direction.get_dim();
-      real_t     xg_min, xg_max, xg_edge;
-      auto       sign = direction.get_sign();
-      real_t     ds;
-      if (sign > 0) { // + direction
-        ds      = ds_array[(short)dim].second;
-        xg_max  = m_metadomain.mesh().extent(dim).second;
-        xg_min  = xg_max - ds;
-        xg_edge = xg_max;
-      } else { // - direction
-        ds      = ds_array[(short)dim].first;
-        xg_min  = m_metadomain.mesh().extent(dim).first;
-        xg_max  = xg_min + ds;
-        xg_edge = xg_min;
-      }
-      boundaries_t<real_t> box;
-      boundaries_t<bool>   incl_ghosts;
-      for (dim_t d { 0 }; d < M::Dim; ++d) {
-        if (d == static_cast<dim_t>(dim)) {
-          box.push_back({ xg_min, xg_max });
-          if (sign > 0) {
-            incl_ghosts.push_back({ false, true });
-          } else {
-            incl_ghosts.push_back({ true, false });
-          }
-        } else {
-          box.push_back(Range::All);
-          incl_ghosts.push_back({ true, true });
-        }
-      }
-      if (not domain.mesh.Intersects(box)) {
-        return;
-      }
-      const auto intersect_range = domain.mesh.ExtentToRange(box, incl_ghosts);
-      tuple_t<ncells_t, M::Dim> range_min { 0 };
-      tuple_t<ncells_t, M::Dim> range_max { 0 };
-
-      for (auto d { 0u }; d < M::Dim; ++d) {
-        range_min[d] = intersect_range[d].first;
-        range_max[d] = intersect_range[d].second;
-      }
-
-      if (dim == in::x1) {
-        if constexpr (
-          traits::has_member<traits::pgen::match_fields_t, pgen_t>::value) {
-          auto match_fields = m_pgen.MatchFields(time);
-          call_match_fields<decltype(match_fields), in::x1>(domain.fields.em,
-                                                            domain.mesh.flds_bc(),
-                                                            match_fields,
-                                                            domain.mesh.metric,
-                                                            xg_edge,
-                                                            ds,
-                                                            tags,
-                                                            range_min,
-                                                            range_max);
-        } else if constexpr (
-          traits::has_member<traits::pgen::match_fields_in_x1_t, pgen_t>::value) {
-          auto match_fields = m_pgen.MatchFieldsInX1(time);
-          call_match_fields<decltype(match_fields), in::x1>(domain.fields.em,
-                                                            domain.mesh.flds_bc(),
-                                                            match_fields,
-                                                            domain.mesh.metric,
-                                                            xg_edge,
-                                                            ds,
-                                                            tags,
-                                                            range_min,
-                                                            range_max);
-        }
-      } else if (dim == in::x2) {
-        if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
-          if constexpr (
-            traits::has_member<traits::pgen::match_fields_t, pgen_t>::value) {
-            auto match_fields = m_pgen.MatchFields(time);
-            call_match_fields<decltype(match_fields), in::x2>(domain.fields.em,
-                                                              domain.mesh.flds_bc(),
-                                                              match_fields,
-                                                              domain.mesh.metric,
-                                                              xg_edge,
-                                                              ds,
-                                                              tags,
-                                                              range_min,
-                                                              range_max);
-          } else if constexpr (
-            traits::has_member<traits::pgen::match_fields_in_x2_t, pgen_t>::value) {
-            auto match_fields = m_pgen.MatchFieldsInX2(time);
-            call_match_fields<decltype(match_fields), in::x2>(domain.fields.em,
-                                                              domain.mesh.flds_bc(),
-                                                              match_fields,
-                                                              domain.mesh.metric,
-                                                              xg_edge,
-                                                              ds,
-                                                              tags,
-                                                              range_min,
-                                                              range_max);
-          }
-        } else {
-          raise::Error("Invalid dimension", HERE);
-        }
-      } else if (dim == in::x3) {
-        if constexpr (M::Dim == Dim::_3D) {
-          if constexpr (
-            traits::has_member<traits::pgen::match_fields_t, pgen_t>::value) {
-            auto match_fields = m_pgen.MatchFields(time);
-            call_match_fields<decltype(match_fields), in::x3>(domain.fields.em,
-                                                              domain.mesh.flds_bc(),
-                                                              match_fields,
-                                                              domain.mesh.metric,
-                                                              xg_edge,
-                                                              ds,
-                                                              tags,
-                                                              range_min,
-                                                              range_max);
-          } else if constexpr (
-            traits::has_member<traits::pgen::match_fields_in_x3_t, pgen_t>::value) {
-            auto match_fields = m_pgen.MatchFieldsInX3(time);
-            call_match_fields<decltype(match_fields), in::x3>(domain.fields.em,
-                                                              domain.mesh.flds_bc(),
-                                                              match_fields,
-                                                              domain.mesh.metric,
-                                                              xg_edge,
-                                                              ds,
-                                                              tags,
-                                                              range_min,
-                                                              range_max);
-          }
-        }
-      } else {
-        raise::Error("Invalid dimension", HERE);
-      }
-    }
-
-    void AxisFieldsIn(dir::direction_t<M::Dim> direction,
-                      domain_t&                domain,
-                      BCTags                   tags) {
-      /**
-       * axis boundaries
-       */
-      if constexpr (M::CoordType != Coord::Cart) {
-        raise::ErrorIf(direction.get_dim() != in::x2,
-                       "Invalid axis direction, should be x2",
-                       HERE);
-        const auto i2_min = domain.mesh.i_min(in::x2);
-        const auto i2_max = domain.mesh.i_max(in::x2);
-        if (direction.get_sign() < 0) {
-          Kokkos::parallel_for(
-            "AxisBCFields",
-            domain.mesh.n_all(in::x1),
-            kernel::bc::AxisBoundaries_kernel<M::Dim, false>(domain.fields.em,
-                                                             i2_min,
-                                                             tags));
-        } else {
-          Kokkos::parallel_for(
-            "AxisBCFields",
-            domain.mesh.n_all(in::x1),
-            kernel::bc::AxisBoundaries_kernel<M::Dim, true>(domain.fields.em,
-                                                            i2_max,
-                                                            tags));
-        }
-      } else {
-        (void)direction;
-        (void)domain;
-        (void)tags;
-        raise::Error("Invalid coordinate type for axis BCs", HERE);
-      }
-    }
-
-    void FixedFieldsIn(dir::direction_t<M::Dim> direction,
-                       domain_t&                domain,
-                       BCTags                   tags) {
-      /**
-       * fixed field boundaries
-       */
-      const auto sign = direction.get_sign();
-      const auto dim  = direction.get_dim();
-      raise::ErrorIf(dim != in::x1 and M::CoordType != Coord::Cart,
-                     "Fixed BCs only implemented for x1 in "
-                     "non-cartesian coordinates",
-                     HERE);
-      em normal_b_comp, tang_e_comp1, tang_e_comp2;
-      if (dim == in::x1) {
-        normal_b_comp = em::bx1;
-        tang_e_comp1  = em::ex2;
-        tang_e_comp2  = em::ex3;
-      } else if (dim == in::x2) {
-        normal_b_comp = em::bx2;
-        tang_e_comp1  = em::ex1;
-        tang_e_comp2  = em::ex3;
-      } else if (dim == in::x3) {
-        normal_b_comp = em::bx3;
-        tang_e_comp1  = em::ex1;
-        tang_e_comp2  = em::ex2;
-      } else {
-        raise::Error("Invalid dimension", HERE);
-      }
-      std::vector<ncells_t> xi_min, xi_max;
-      const std::vector<in> all_dirs { in::x1, in::x2, in::x3 };
-      for (dim_t d { 0u }; d < M::Dim; ++d) {
-        const auto dd = all_dirs[d];
-        if (dim == dd) {
-          if (sign > 0) { // + direction
-            xi_min.push_back(domain.mesh.n_all(dd) - N_GHOSTS);
-            xi_max.push_back(domain.mesh.n_all(dd));
-          } else { // - direction
-            xi_min.push_back(0);
-            xi_max.push_back(N_GHOSTS);
-          }
-        } else {
-          xi_min.push_back(0);
-          xi_max.push_back(domain.mesh.n_all(dd));
-        }
-      }
-      raise::ErrorIf(xi_min.size() != xi_max.size() or
-                       xi_min.size() != static_cast<std::size_t>(M::Dim),
-                     "Invalid range size",
-                     HERE);
-      std::vector<unsigned short> comps;
-      if (tags & BC::E) {
-        comps.push_back(tang_e_comp1);
-        comps.push_back(tang_e_comp2);
-      }
-      if (tags & BC::B) {
-        comps.push_back(normal_b_comp);
-      }
-      if constexpr (traits::has_member<traits::pgen::fix_fields_t, pgen_t>::value) {
-        raise::Error("Non-const fixed fields not implemented", HERE);
-      } else if constexpr (
-        traits::has_member<traits::pgen::fix_fields_const_t, pgen_t>::value) {
-        for (const auto& comp : comps) {
-          auto value     = ZERO;
-          bool shouldset = false;
-          if constexpr (
-            traits::has_member<traits::pgen::fix_fields_const_t, pgen_t>::value) {
-            // if fix field function present, read from it
-            const auto newset = m_pgen.FixFieldsConst(
-              (bc_in)(sign * ((short)dim + 1)),
-              (em)comp);
-            value     = newset.first;
-            shouldset = newset.second;
-          }
-          if (shouldset) {
-            if constexpr (M::Dim == Dim::_1D) {
-              Kokkos::deep_copy(
-                Kokkos::subview(domain.fields.em,
-                                std::make_pair(xi_min[0], xi_max[0]),
-                                comp),
-                value);
-            } else if constexpr (M::Dim == Dim::_2D) {
-              Kokkos::deep_copy(
-                Kokkos::subview(domain.fields.em,
-                                std::make_pair(xi_min[0], xi_max[0]),
-                                std::make_pair(xi_min[1], xi_max[1]),
-                                comp),
-                value);
-            } else if constexpr (M::Dim == Dim::_3D) {
-              Kokkos::deep_copy(
-                Kokkos::subview(domain.fields.em,
-                                std::make_pair(xi_min[0], xi_max[0]),
-                                std::make_pair(xi_min[1], xi_max[1]),
-                                std::make_pair(xi_min[2], xi_max[2]),
-                                comp),
-                value);
-            } else {
-              raise::Error("Invalid dimension", HERE);
-            }
-          }
-        }
-      } else {
-        (void)direction;
-        (void)domain;
-        (void)tags;
-        raise::Error("Fixed fields not present (both const and non-const)", HERE);
-      }
-    }
-
-    void PerfectConductorFieldsIn(dir::direction_t<M::Dim> direction,
-                                  domain_t&                domain,
-                                  BCTags                   tags) {
-      /**
-       * perfect conductor field boundaries
-       */
-      if constexpr (M::CoordType != Coord::Cart) {
-        (void)direction;
-        (void)domain;
-        (void)tags;
-        raise::Error(
-          "Perfect conductor BCs only applicable to cartesian coordinates",
-          HERE);
-      } else {
-        const auto sign = direction.get_sign();
-        const auto dim  = direction.get_dim();
-
-        std::vector<std::size_t> xi_min, xi_max;
-
-        const std::vector<in> all_dirs { in::x1, in::x2, in::x3 };
-
-        for (auto d { 0u }; d < M::Dim; ++d) {
-          const auto dd = all_dirs[d];
-          if (dim == dd) {
-            xi_min.push_back(0);
-            xi_max.push_back((sign < 0) ? (N_GHOSTS + 1) : N_GHOSTS);
-          } else {
-            xi_min.push_back(0);
-            xi_max.push_back(domain.mesh.n_all(dd));
-          }
-        }
-        raise::ErrorIf(xi_min.size() != xi_max.size() or
-                         xi_min.size() != static_cast<std::size_t>(M::Dim),
-                       "Invalid range size",
-                       HERE);
-
-        range_t<M::Dim> range;
-        if constexpr (M::Dim == Dim::_1D) {
-          range = CreateRangePolicy<M::Dim>({ xi_min[0] }, { xi_max[0] });
-        } else if constexpr (M::Dim == Dim::_2D) {
-          range = CreateRangePolicy<M::Dim>({ xi_min[0], xi_min[1] },
-                                            { xi_max[0], xi_max[1] });
-        } else if constexpr (M::Dim == Dim::_3D) {
-          range = CreateRangePolicy<M::Dim>({ xi_min[0], xi_min[1], xi_min[2] },
-                                            { xi_max[0], xi_max[1], xi_max[2] });
-        } else {
-          raise::Error("Invalid dimension", HERE);
-        }
-        std::size_t i_edge;
-        if (sign > 0) {
-          i_edge = domain.mesh.i_max(dim);
-        } else {
-          i_edge = domain.mesh.i_min(dim);
-        }
-
-        if (dim == in::x1) {
-          if (sign > 0) {
-            Kokkos::parallel_for(
-              "ConductorFields",
-              range,
-              kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x1, true>(
-                domain.fields.em,
-                i_edge,
-                tags));
-          } else {
-            Kokkos::parallel_for(
-              "ConductorFields",
-              range,
-              kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x1, false>(
-                domain.fields.em,
-                i_edge,
-                tags));
-          }
-        } else if (dim == in::x2) {
-          if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
-            if (sign > 0) {
-              Kokkos::parallel_for(
-                "ConductorFields",
-                range,
-                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x2, true>(
-                  domain.fields.em,
-                  i_edge,
-                  tags));
-            } else {
-              Kokkos::parallel_for(
-                "ConductorFields",
-                range,
-                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x2, false>(
-                  domain.fields.em,
-                  i_edge,
-                  tags));
-            }
-          } else {
-            raise::Error("Invalid dimension", HERE);
-          }
-        } else {
-          if constexpr (M::Dim == Dim::_3D) {
-            if (sign > 0) {
-              Kokkos::parallel_for(
-                "ConductorFields",
-                range,
-                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x3, true>(
-                  domain.fields.em,
-                  i_edge,
-                  tags));
-            } else {
-              Kokkos::parallel_for(
-                "ConductorFields",
-                range,
-                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x3, false>(
-                  domain.fields.em,
-                  i_edge,
-                  tags));
-            }
-          } else {
-            raise::Error("Invalid dimension", HERE);
-          }
-        }
-      }
-    }
-
-    void AtmosphereFieldsIn(dir::direction_t<M::Dim> direction,
-                            domain_t&                domain,
-                            BCTags                   tags) {
-      /**
-       * atmosphere field boundaries
-       */
-      if constexpr (traits::has_member<traits::pgen::atm_fields_t, pgen_t>::value) {
-        const auto [sign, dim, xg_min, xg_max] = get_atm_extent(direction);
-        const auto           dd                = static_cast<dim_t>(dim);
-        boundaries_t<real_t> box;
-        boundaries_t<bool>   incl_ghosts;
-        for (auto d { 0u }; d < M::Dim; ++d) {
-          if (d == dd) {
-            box.push_back({ xg_min, xg_max });
-            if (sign > 0) {
-              incl_ghosts.push_back({ false, true });
-            } else {
-              incl_ghosts.push_back({ true, false });
-            }
-          } else {
-            box.push_back(Range::All);
-            incl_ghosts.push_back({ true, true });
-          }
-        }
-        if (not domain.mesh.Intersects(box)) {
-          return;
-        }
-        const auto intersect_range = domain.mesh.ExtentToRange(box, incl_ghosts);
-        tuple_t<std::size_t, M::Dim> range_min { 0 };
-        tuple_t<std::size_t, M::Dim> range_max { 0 };
-
-        for (auto d { 0u }; d < M::Dim; ++d) {
-          range_min[d] = intersect_range[d].first;
-          range_max[d] = intersect_range[d].second;
-        }
-        auto        atm_fields = m_pgen.AtmFields(time);
-        std::size_t il_edge;
-        if (sign > 0) {
-          il_edge = range_min[dd] - N_GHOSTS;
-        } else {
-          il_edge = range_max[dd] - 1 - N_GHOSTS;
-        }
-        const auto range = CreateRangePolicy<M::Dim>(range_min, range_max);
-        if (dim == in::x1) {
-          if (sign > 0) {
-            Kokkos::parallel_for(
-              "AtmosphereBCFields",
-              range,
-              kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x1>(
-                domain.fields.em,
-                atm_fields,
-                domain.mesh.metric,
-                il_edge,
-                tags));
-          } else {
-            Kokkos::parallel_for(
-              "AtmosphereBCFields",
-              range,
-              kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x1>(
-                domain.fields.em,
-                atm_fields,
-                domain.mesh.metric,
-                il_edge,
-                tags));
-          }
-        } else if (dim == in::x2) {
-          if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
-            if (sign > 0) {
-              Kokkos::parallel_for(
-                "AtmosphereBCFields",
-                range,
-                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x2>(
-                  domain.fields.em,
-                  atm_fields,
-                  domain.mesh.metric,
-                  il_edge,
-                  tags));
-            } else {
-              Kokkos::parallel_for(
-                "AtmosphereBCFields",
-                range,
-                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x2>(
-                  domain.fields.em,
-                  atm_fields,
-                  domain.mesh.metric,
-                  il_edge,
-                  tags));
-            }
-          } else {
-            raise::Error("Invalid dimension", HERE);
-          }
-        } else if (dim == in::x3) {
-          if constexpr (M::Dim == Dim::_3D) {
-            if (sign > 0) {
-              Kokkos::parallel_for(
-                "AtmosphereBCFields",
-                range,
-                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x3>(
-                  domain.fields.em,
-                  atm_fields,
-                  domain.mesh.metric,
-                  il_edge,
-                  tags));
-            } else {
-              Kokkos::parallel_for(
-                "AtmosphereBCFields",
-                range,
-                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x3>(
-                  domain.fields.em,
-                  atm_fields,
-                  domain.mesh.metric,
-                  il_edge,
-                  tags));
-            }
-          } else {
-            raise::Error("Invalid dimension", HERE);
-          }
-        } else {
-          raise::Error("Invalid dimension", HERE);
-        }
-      } else {
-        (void)direction;
-        (void)domain;
-        (void)tags;
-        raise::Error("Atm fields not implemented in PGEN for atmosphere BCs", HERE);
-      }
-    }
-
-    void CustomFieldsIn(dir::direction_t<M::Dim> direction,
-                        domain_t&                domain,
-                        BCTags                   tags) {
-      (void)direction;
-      (void)domain;
-      (void)tags;
-      raise::Error("Custom boundaries not implemented", HERE);
-      // if constexpr (
-      //   traits::has_member<traits::pgen::custom_fields_t, pgen_t>::value) {
-      //   const auto [box, custom_fields] = m_pgen.CustomFields(time);
-      //   if (domain.mesh.Intersects(box)) {
-      //   }
-      //
-      // } else {
-      //   raise::Error("Custom boundaries not implemented", HERE);
-      // }
-    }
-
-    void AtmosphereParticlesIn(const dir::direction_t<M::Dim>& direction,
-                               domain_t&                       domain,
-                               InjTags                         tags) {
-      const auto [sign, dim, xg_min, xg_max] = get_atm_extent(direction);
-
-      const auto x_surf = sign > 0 ? xg_min : xg_max;
-      const auto ds     = m_params.template get<real_t>(
-        "grid.boundaries.atmosphere.ds");
-      const auto temp = m_params.template get<real_t>(
-        "grid.boundaries.atmosphere.temperature");
-      const auto height = m_params.template get<real_t>(
-        "grid.boundaries.atmosphere.height");
-      const auto species = m_params.template get<std::pair<spidx_t, spidx_t>>(
-        "grid.boundaries.atmosphere.species");
-      const auto nmax = m_params.template get<real_t>(
-        "grid.boundaries.atmosphere.density");
-
-      Kokkos::deep_copy(domain.fields.bckp, ZERO);
-      auto scatter_bckp = Kokkos::Experimental::create_scatter_view(
-        domain.fields.bckp);
-      const auto use_weights = M::CoordType != Coord::Cart;
-      const auto ni2         = domain.mesh.n_active(in::x2);
-      const auto inv_n0      = ONE / m_params.template get<real_t>("scales.n0");
-
-      // compute the density of the two species
-      if (tags & Inj::AssumeEmpty) {
-        if constexpr (M::Dim == Dim::_1D) {
-          Kokkos::deep_copy(
-            Kokkos::subview(domain.fields.bckp, Kokkos::ALL, std::make_pair(0, 1)),
-            ZERO);
-        } else if constexpr (M::Dim == Dim::_2D) {
-          Kokkos::deep_copy(Kokkos::subview(domain.fields.bckp,
-                                            Kokkos::ALL,
-                                            Kokkos::ALL,
-                                            std::make_pair(0, 1)),
-                            ZERO);
-        } else if constexpr (M::Dim == Dim::_3D) {
-          Kokkos::deep_copy(Kokkos::subview(domain.fields.bckp,
-                                            Kokkos::ALL,
-                                            Kokkos::ALL,
-                                            Kokkos::ALL,
-                                            std::make_pair(0, 1)),
-                            ZERO);
-        }
-      } else {
-        for (const auto& sp :
-             std::vector<spidx_t> { species.first, species.second }) {
-          auto& prtl_spec = domain.species[sp - 1];
-          if (prtl_spec.npart() == 0) {
-            continue;
-          }
-          // clang-format off
-          Kokkos::parallel_for(
-            "ComputeMoments",
-            prtl_spec.rangeActiveParticles(),
-            kernel::ParticleMoments_kernel<SimEngine::SRPIC, M, FldsID::Rho, 6>(
-              {}, scatter_bckp, 0,
-              prtl_spec.i1, prtl_spec.i2, prtl_spec.i3,
-              prtl_spec.dx1, prtl_spec.dx2, prtl_spec.dx3,
-              prtl_spec.ux1, prtl_spec.ux2, prtl_spec.ux3,
-              prtl_spec.phi, prtl_spec.weight, prtl_spec.tag,
-              prtl_spec.mass(), prtl_spec.charge(),
-              use_weights,
-              domain.mesh.metric, domain.mesh.flds_bc(),
-              ni2, inv_n0, 0));
-          // clang-format on
-          prtl_spec.set_unsorted();
-        }
-        Kokkos::Experimental::contribute(domain.fields.bckp, scatter_bckp);
-        m_metadomain.SynchronizeFields(domain, Comm::Bckp, { 0, 1 });
-      }
-
-      const auto maxwellian = arch::Maxwellian<S, M> { domain.mesh.metric,
-                                                       domain.random_pool(),
-                                                       temp };
-
-      if (dim == in::x1) {
-        if (sign > 0) {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x1> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        } else {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x1> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        }
-      } else if (dim == in::x2) {
-        if (sign > 0) {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x2> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        } else {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x2> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        }
-      } else if (dim == in::x3) {
-        if (sign > 0) {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x3> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        } else {
-          auto target_density =
-            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x3> {
-              nmax,
-              height,
-              x_surf,
-              ds
-            };
-          const auto spatial_dist = arch::Replenish<S, M, 6, decltype(target_density)> {
-            domain.mesh.metric,
-            domain.fields.bckp,
-            0,
-            target_density,
-            nmax
-          };
-          arch::InjectNonUniform<S, M, decltype(maxwellian), decltype(maxwellian), decltype(spatial_dist)>(
-            m_params,
-            domain,
-            { species.first, species.second },
-            { maxwellian, maxwellian },
-            spatial_dist,
-            nmax,
-            use_weights);
-        }
-      } else {
-        raise::Error("Invalid dimension", HERE);
-      }
-      return;
-    }
-
-  private:
-    /**
-     * @brief Get the buffer region of the atmosphere and the direction
-     * @param direction direction in which the atmosphere is applied
-     * @return tuple: [sign of the direction, the direction (as in::), the min and max extent
-     * @note xg_min and xg_max are the extents where the fields are set, not the atmosphere itself
-     * @note i.e.
-     *
-     *         fields set      particles injected
-     * ghost zone  |               |
-     *    v        v               v
-     * |....|...........|*******************.....  -> x1
-     * ^                ^
-     * xg_min         xg_max
-     * |                |                  |
-     * |<--  buffer  -->|<-- atmosphere -->|
-     *
-     * in this case the function returns { -1, in::x1, xg_min, xg_max }
-     */
-    auto get_atm_extent(dir::direction_t<M::Dim> direction) const
-      -> std::tuple<short, in, real_t, real_t> {
-      const auto sign     = direction.get_sign();
-      const auto dim      = direction.get_dim();
-      const auto min_buff = m_params.template get<unsigned short>(
-                              "algorithms.current_filters") +
-                            2;
-      const auto buffer_ncells = min_buff > 5 ? min_buff : 5;
-      if (M::CoordType != Coord::Cart and (dim != in::x1 or sign > 0)) {
-        raise::Error("For non-cartesian coordinates atmosphere BCs is "
-                     "possible only in -x1 (@ rmin)",
-                     HERE);
-      }
-      real_t   xg_min { ZERO }, xg_max { ZERO };
-      ncells_t ig_min, ig_max;
-      if (sign > 0) { // + direction
-        ig_min = m_metadomain.mesh().n_active(dim) - buffer_ncells;
-        ig_max = m_metadomain.mesh().n_active(dim);
-      } else { // - direction
-        ig_min = 0;
-        ig_max = buffer_ncells;
-      }
-
-      if (dim == in::x1) {
-        xg_min = m_metadomain.mesh().metric.template convert<1, Crd::Cd, Crd::Ph>(
-          static_cast<real_t>(ig_min));
-        xg_max = m_metadomain.mesh().metric.template convert<1, Crd::Cd, Crd::Ph>(
-          static_cast<real_t>(ig_max));
-      } else if (dim == in::x2) {
-        if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
-          xg_min = m_metadomain.mesh().metric.template convert<2, Crd::Cd, Crd::Ph>(
-            static_cast<real_t>(ig_min));
-          xg_max = m_metadomain.mesh().metric.template convert<2, Crd::Cd, Crd::Ph>(
-            static_cast<real_t>(ig_max));
-        } else {
-          raise::Error("Invalid dimension", HERE);
-        }
-      } else if (dim == in::x3) {
-        if constexpr (M::Dim == Dim::_3D) {
-          xg_min = m_metadomain.mesh().metric.template convert<3, Crd::Cd, Crd::Ph>(
-            static_cast<real_t>(ig_min));
-          xg_max = m_metadomain.mesh().metric.template convert<3, Crd::Cd, Crd::Ph>(
-            static_cast<real_t>(ig_max));
-        } else {
-          raise::Error("Invalid dimension", HERE);
-        }
-      } else {
-        raise::Error("Invalid dimension", HERE);
-      }
-      return { sign, dim, xg_min, xg_max };
-    }
-
-    auto range_with_axis_BCs(const domain_t& domain) -> range_t<M::Dim> {
-      auto range = domain.mesh.rangeActiveCells();
-      if constexpr (M::CoordType != Coord::Cart) {
-        /**
-         * @brief taking one extra cell in the x2 direction if AXIS BCs
-         */
-        if constexpr (M::Dim == Dim::_2D) {
-          if (domain.mesh.flds_bc_in({ 0, +1 }) == FldsBC::AXIS) {
-            range = CreateRangePolicy<Dim::_2D>(
-              { domain.mesh.i_min(in::x1), domain.mesh.i_min(in::x2) },
-              { domain.mesh.i_max(in::x1), domain.mesh.i_max(in::x2) + 1 });
-          }
-        } else if constexpr (M::Dim == Dim::_3D) {
-          if (domain.mesh.flds_bc_in({ 0, +1, 0 }) == FldsBC::AXIS) {
-            range = CreateRangePolicy<Dim::_3D>({ domain.mesh.i_min(in::x1),
-                                                  domain.mesh.i_min(in::x2),
-                                                  domain.mesh.i_min(in::x3) },
-                                                { domain.mesh.i_max(in::x1),
-                                                  domain.mesh.i_max(in::x2) + 1,
-                                                  domain.mesh.i_max(in::x3) });
-          }
-        }
-      }
-      return range;
-    }
-
-    template <class T, in O>
-    void call_match_fields(ndfield_t<M::Dim, 6>&       fields,
-                           const boundaries_t<FldsBC>& boundaries,
-                           const T&                    match_fields,
-                           const M&                    metric,
-                           real_t                      xg_edge,
-                           real_t                      ds,
-                           BCTags                      tags,
-                           tuple_t<ncells_t, M::Dim>&  range_min,
-                           tuple_t<ncells_t, M::Dim>&  range_max) {
-      Kokkos::parallel_for(
-        "MatchFields",
-        CreateRangePolicy<M::Dim>(range_min, range_max),
-        kernel::bc::MatchBoundaries_kernel<SimEngine::SRPIC, T, M, O>(fields,
-                                                                      match_fields,
-                                                                      metric,
-                                                                      xg_edge,
-                                                                      ds,
-                                                                      tags,
-                                                                      boundaries));
-    }
-  };
-
-} // namespace ntt
-
-#endif // ENGINES_SRPIC_SRPIC_H
diff --git a/src/engines/srpic/currents.h b/src/engines/srpic/currents.h
new file mode 100644
index 000000000..479ba0bc6
--- /dev/null
+++ b/src/engines/srpic/currents.h
@@ -0,0 +1,117 @@
+#ifndef ENGINES_SRPIC_CURRENTS_H
+#define ENGINES_SRPIC_CURRENTS_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "arch/kokkos_aliases.h"
+#include "utils/log.h"
+#include "utils/param_container.h"
+
+#include "metrics/traits.h"
+
+#include "engines/srpic/utils.h"
+#include "framework/domain/domain.h"
+#include "framework/domain/metadomain.h"
+
+#include "kernels/currents_deposit.hpp"
+#include "kernels/digital_filter.hpp"
+
+namespace ntt {
+  namespace srpic {
+
+    template <class M, unsigned short O>
+      requires metric::traits::HasD<M> && metric::traits::HasCoordType<M>
+    void CallDepositKernel(const Particles<M::Dim, M::CoordType>& species,
+                           const M&                               local_metric,
+                           const scatter_ndfield_t<M::Dim, 3>&    scatter_cur,
+                           real_t                                 dt) {
+      Kokkos::parallel_for("CurrentsDeposit",
+                           species.rangeActiveParticles(),
+                           kernel::DepositCurrents_kernel<SimEngine::SRPIC, M, O>(
+                             scatter_cur,
+                             species.i1,
+                             species.i2,
+                             species.i3,
+                             species.i1_prev,
+                             species.i2_prev,
+                             species.i3_prev,
+                             species.dx1,
+                             species.dx2,
+                             species.dx3,
+                             species.dx1_prev,
+                             species.dx2_prev,
+                             species.dx3_prev,
+                             species.ux1,
+                             species.ux2,
+                             species.ux3,
+                             species.phi,
+                             species.weight,
+                             species.tag,
+                             local_metric,
+                             (real_t)(species.charge()),
+                             dt));
+    }
+
+    template <class M>
+    void CurrentsDeposit(Domain<SimEngine::SRPIC, M>& domain,
+                         const prm::Parameters&       engine_params) {
+      const auto dt = engine_params.get<real_t>("dt");
+      Kokkos::deep_copy(domain.fields.cur, ZERO);
+      auto scatter_cur = Kokkos::Experimental::create_scatter_view(
+        domain.fields.cur);
+      for (auto& species : domain.species) {
+        if ((species.pusher() == ParticlePusher::NONE) or
+            (species.npart() == 0) or cmp::AlmostZero_host(species.charge())) {
+          continue;
+        }
+        logger::Checkpoint(
+          fmt::format("Launching currents deposit kernel for %d [%s] : %lu %f",
+                      species.index(),
+                      species.label().c_str(),
+                      species.npart(),
+                      (double)species.charge()),
+          HERE);
+
+        CallDepositKernel<M, SHAPE_ORDER>(species, domain.mesh.metric, scatter_cur, dt);
+      }
+      Kokkos::Experimental::contribute(domain.fields.cur, scatter_cur);
+    }
+
+    template <class M>
+      requires metric::traits::HasD<M> && metric::traits::HasCoordType<M>
+    void CurrentsFilter(Metadomain<SimEngine::SRPIC, M>& metadomain,
+                        Domain<SimEngine::SRPIC, M>&     domain,
+                        const SimulationParams&          params) {
+      logger::Checkpoint("Launching currents filtering kernels", HERE);
+      auto       range   = srpic::RangeWithAxisBCs(domain);
+      const auto nfilter = params.template get<unsigned short>(
+        "algorithms.current_filters");
+      tuple_t<ncells_t, M::Dim> size;
+      if constexpr (M::Dim == Dim::_1D || M::Dim == Dim::_2D || M::Dim == Dim::_3D) {
+        size[0] = domain.mesh.n_active(in::x1);
+      }
+      if constexpr (M::Dim == Dim::_2D || M::Dim == Dim::_3D) {
+        size[1] = domain.mesh.n_active(in::x2);
+      }
+      if constexpr (M::Dim == Dim::_3D) {
+        size[2] = domain.mesh.n_active(in::x3);
+      }
+      // !TODO: this needs to be done more efficiently
+      for (auto i { 0u }; i < nfilter; ++i) {
+        Kokkos::deep_copy(domain.fields.buff, domain.fields.cur);
+        Kokkos::parallel_for("CurrentsFilter",
+                             range,
+                             kernel::DigitalFilter_kernel<M::Dim, M::CoordType>(
+                               domain.fields.cur,
+                               domain.fields.buff,
+                               size,
+                               domain.mesh.flds_bc()));
+        metadomain.CommunicateFields(domain, Comm::J);
+      }
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif // ENGINES_SRPIC_CURRENTS_H
diff --git a/src/engines/srpic/fields_bcs.h b/src/engines/srpic/fields_bcs.h
new file mode 100644
index 000000000..07792002b
--- /dev/null
+++ b/src/engines/srpic/fields_bcs.h
@@ -0,0 +1,675 @@
+#ifndef ENGINES_SRPIC_FIELDS_BCS_H
+#define ENGINES_SRPIC_FIELDS_BCS_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "arch/directions.h"
+#include "utils/numeric.h"
+
+#include "metrics/traits.h"
+
+#include "archetypes/traits.h"
+#include "engines/srpic/utils.h"
+#include "framework/domain/domain.h"
+#include "framework/parameters/parameters.h"
+
+#include "kernels/fields_bcs.hpp"
+
+namespace ntt {
+  namespace srpic {
+
+    template <class M, class T, in O>
+      requires metric::traits::HasD<M>
+    void CallMatchFields(ndfield_t<M::Dim, 6>&       fields,
+                         const boundaries_t<FldsBC>& boundaries,
+                         const T&                    match_fields,
+                         const M&                    metric,
+                         real_t                      xg_edge,
+                         real_t                      ds,
+                         BCTags                      tags,
+                         tuple_t<ncells_t, M::Dim>&  range_min,
+                         tuple_t<ncells_t, M::Dim>&  range_max) {
+      Kokkos::parallel_for(
+        "MatchFields",
+        CreateRangePolicy<M::Dim>(range_min, range_max),
+        kernel::bc::MatchBoundaries_kernel<SimEngine::SRPIC, T, M, O>(fields,
+                                                                      match_fields,
+                                                                      metric,
+                                                                      xg_edge,
+                                                                      ds,
+                                                                      tags,
+                                                                      boundaries));
+    }
+
+    template <class M, class PG>
+      requires metric::traits::HasD<M>
+    void MatchFieldsIn(dir::direction_t<M::Dim>     direction,
+                       Domain<SimEngine::SRPIC, M>& domain,
+                       const Grid<M::Dim>&          global_grid,
+                       const PG&                    pgen,
+                       const prm::Parameters&       engine_params,
+                       const SimulationParams&      params,
+                       BCTags                       tags) {
+      const auto time     = engine_params.get<simtime_t>("time");
+      /**
+       * matching boundaries
+       */
+      const auto ds_array = params.template get<boundaries_t<real_t>>(
+        "grid.boundaries.match.ds");
+      const auto dim = direction.get_dim();
+      real_t     xg_min, xg_max, xg_edge;
+      auto       sign = direction.get_sign();
+      real_t     ds;
+      if (sign > 0) { // + direction
+        ds      = ds_array[(short)dim].second;
+        xg_max  = global_grid.extent(dim).second;
+        xg_min  = xg_max - ds;
+        xg_edge = xg_max;
+      } else { // - direction
+        ds      = ds_array[(short)dim].first;
+        xg_min  = global_grid.extent(dim).first;
+        xg_max  = xg_min + ds;
+        xg_edge = xg_min;
+      }
+      boundaries_t<real_t> box;
+      boundaries_t<bool>   incl_ghosts;
+      for (dim_t d { 0 }; d < M::Dim; ++d) {
+        if (d == static_cast<dim_t>(dim)) {
+          box.push_back({ xg_min, xg_max });
+          if (sign > 0) {
+            incl_ghosts.push_back({ false, true });
+          } else {
+            incl_ghosts.push_back({ true, false });
+          }
+        } else {
+          box.push_back(Range::All);
+          incl_ghosts.push_back({ true, true });
+        }
+      }
+      if (not domain.mesh.Intersects(box)) {
+        return;
+      }
+      const auto intersect_range = domain.mesh.ExtentToRange(box, incl_ghosts);
+      tuple_t<ncells_t, M::Dim> range_min { 0 };
+      tuple_t<ncells_t, M::Dim> range_max { 0 };
+
+      for (auto d { 0u }; d < M::Dim; ++d) {
+        range_min[d] = intersect_range[d].first;
+        range_max[d] = intersect_range[d].second;
+      }
+
+      if (dim == in::x1) {
+        if constexpr (arch::traits::pgen::HasMatchFields<PG>) {
+          auto match_fields = pgen.MatchFields(time);
+          CallMatchFields<M, decltype(match_fields), in::x1>(domain.fields.em,
+                                                             domain.mesh.flds_bc(),
+                                                             match_fields,
+                                                             domain.mesh.metric,
+                                                             xg_edge,
+                                                             ds,
+                                                             tags,
+                                                             range_min,
+                                                             range_max);
+        } else if constexpr (arch::traits::pgen::HasMatchFieldsInX1<PG>) {
+          auto match_fields = pgen.MatchFieldsInX1(time);
+          CallMatchFields<M, decltype(match_fields), in::x1>(domain.fields.em,
+                                                             domain.mesh.flds_bc(),
+                                                             match_fields,
+                                                             domain.mesh.metric,
+                                                             xg_edge,
+                                                             ds,
+                                                             tags,
+                                                             range_min,
+                                                             range_max);
+        }
+      } else if (dim == in::x2) {
+        if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
+          if constexpr (arch::traits::pgen::HasMatchFields<PG>) {
+            auto match_fields = pgen.MatchFields(time);
+            CallMatchFields<M, decltype(match_fields), in::x2>(
+              domain.fields.em,
+              domain.mesh.flds_bc(),
+              match_fields,
+              domain.mesh.metric,
+              xg_edge,
+              ds,
+              tags,
+              range_min,
+              range_max);
+          } else if constexpr (arch::traits::pgen::HasMatchFieldsInX2<PG>) {
+            auto match_fields = pgen.MatchFieldsInX2(time);
+            CallMatchFields<M, decltype(match_fields), in::x2>(
+              domain.fields.em,
+              domain.mesh.flds_bc(),
+              match_fields,
+              domain.mesh.metric,
+              xg_edge,
+              ds,
+              tags,
+              range_min,
+              range_max);
+          }
+        } else {
+          raise::Error("Invalid dimension", HERE);
+        }
+      } else if (dim == in::x3) {
+        if constexpr (M::Dim == Dim::_3D) {
+          if constexpr (arch::traits::pgen::HasMatchFields<PG>) {
+            auto match_fields = pgen.MatchFields(time);
+            CallMatchFields<M, decltype(match_fields), in::x3>(
+              domain.fields.em,
+              domain.mesh.flds_bc(),
+              match_fields,
+              domain.mesh.metric,
+              xg_edge,
+              ds,
+              tags,
+              range_min,
+              range_max);
+          } else if constexpr (arch::traits::pgen::HasMatchFieldsInX3<PG>) {
+            auto match_fields = pgen.MatchFieldsInX3(time);
+            CallMatchFields<M, decltype(match_fields), in::x3>(
+              domain.fields.em,
+              domain.mesh.flds_bc(),
+              match_fields,
+              domain.mesh.metric,
+              xg_edge,
+              ds,
+              tags,
+              range_min,
+              range_max);
+          }
+        }
+      } else {
+        raise::Error("Invalid dimension", HERE);
+      }
+    }
+
+    template <class M>
+      requires metric::traits::HasD<M>
+    void AxisFieldsIn(dir::direction_t<M::Dim>     direction,
+                      Domain<SimEngine::SRPIC, M>& domain,
+                      BCTags                       tags) {
+      /**
+       * axis boundaries
+       */
+      if constexpr (M::CoordType != Coord::Cart) {
+        raise::ErrorIf(direction.get_dim() != in::x2,
+                       "Invalid axis direction, should be x2",
+                       HERE);
+        const auto i2_min = domain.mesh.i_min(in::x2);
+        const auto i2_max = domain.mesh.i_max(in::x2);
+        if (direction.get_sign() < 0) {
+          Kokkos::parallel_for(
+            "AxisBCFields",
+            domain.mesh.n_all(in::x1),
+            kernel::bc::AxisBoundaries_kernel<M::Dim, false>(domain.fields.em,
+                                                             i2_min,
+                                                             tags));
+        } else {
+          Kokkos::parallel_for(
+            "AxisBCFields",
+            domain.mesh.n_all(in::x1),
+            kernel::bc::AxisBoundaries_kernel<M::Dim, true>(domain.fields.em,
+                                                            i2_max,
+                                                            tags));
+        }
+      } else {
+        (void)direction;
+        (void)domain;
+        (void)tags;
+        raise::Error("Invalid coordinate type for axis BCs", HERE);
+      }
+    }
+
+    template <class M, class PG>
+      requires metric::traits::HasD<M> and metric::traits::HasCoordType<M> and
+               metric::traits::HasTransform_i<M>
+    void FixedFieldsIn(dir::direction_t<M::Dim>     direction,
+                       Domain<SimEngine::SRPIC, M>& domain,
+                       const PG&                    pgen,
+                       const prm::Parameters&       engine_params,
+                       BCTags                       tags) {
+      const auto time = engine_params.get<simtime_t>("time");
+      /**
+       * fixed field boundaries
+       */
+      const auto sign = direction.get_sign();
+      const auto dim  = direction.get_dim();
+      raise::ErrorIf(dim != in::x1 and M::CoordType != Coord::Cart,
+                     "Fixed BCs only implemented for x1 in "
+                     "non-cartesian coordinates",
+                     HERE);
+      std::vector<ncells_t> xi_min, xi_max;
+      const std::vector<in> all_dirs { in::x1, in::x2, in::x3 };
+      for (dim_t d { 0u }; d < M::Dim; ++d) {
+        const auto dd = all_dirs[d];
+        if (dim == dd) {
+          if (sign > 0) { // + direction
+            xi_min.push_back(domain.mesh.n_all(dd) - N_GHOSTS);
+            xi_max.push_back(domain.mesh.n_all(dd));
+          } else { // - direction
+            xi_min.push_back(0);
+            xi_max.push_back(N_GHOSTS);
+          }
+        } else {
+          xi_min.push_back(0);
+          xi_max.push_back(domain.mesh.n_all(dd));
+        }
+      }
+      raise::ErrorIf(xi_min.size() != xi_max.size() or
+                       xi_min.size() != static_cast<std::size_t>(M::Dim),
+                     "Invalid range size",
+                     HERE);
+      std::vector<unsigned short> comps;
+      if (tags & BC::E) {
+        comps.push_back(em::ex1);
+        comps.push_back(em::ex2);
+        comps.push_back(em::ex3);
+      }
+      if (tags & BC::B) {
+        comps.push_back(em::bx1);
+        comps.push_back(em::bx2);
+        comps.push_back(em::bx3);
+      }
+      if constexpr (arch::traits::pgen::HasFixFieldsConst<PG>) {
+        raise::ErrorIf(M::CoordType != Coord::Cart and dim != in::x1,
+                       "FixedFields cannot be used for non-cartesian metric",
+                       HERE);
+        for (const auto& comp : comps) {
+          auto       value     = ZERO;
+          bool       shouldset = false;
+          // if fix field function present, read from it
+          const auto newset    = pgen.FixFieldsConst(time,
+                                                  (bc_in)(sign * ((short)dim + 1)),
+                                                  (em)comp);
+          value                = newset.first;
+          shouldset            = newset.second;
+          if (shouldset) {
+            // convert tetrad basis field (T) to contravariant (U)
+            real_t value_U = ZERO;
+            if (comp == em::ex1 or comp == em::bx1) {
+              value_U = domain.mesh.metric.template transform<1, Idx::T, Idx::U>(
+                { ZERO },
+                value);
+            } else if (comp == em::ex2 or comp == em::bx2) {
+              value_U = domain.mesh.metric.template transform<2, Idx::T, Idx::U>(
+                { ZERO },
+                value);
+            } else if (comp == em::ex3 or comp == em::bx3) {
+              value_U = domain.mesh.metric.template transform<3, Idx::T, Idx::U>(
+                { ZERO },
+                value);
+            } else {
+              raise::Error("Invalid EM component", HERE);
+            }
+            if constexpr (M::Dim == Dim::_1D) {
+              Kokkos::deep_copy(
+                Kokkos::subview(domain.fields.em,
+                                std::make_pair(xi_min[0], xi_max[0]),
+                                comp),
+                value_U);
+            } else if constexpr (M::Dim == Dim::_2D) {
+              Kokkos::deep_copy(
+                Kokkos::subview(domain.fields.em,
+                                std::make_pair(xi_min[0], xi_max[0]),
+                                std::make_pair(xi_min[1], xi_max[1]),
+                                comp),
+                value_U);
+            } else if constexpr (M::Dim == Dim::_3D) {
+              Kokkos::deep_copy(
+                Kokkos::subview(domain.fields.em,
+                                std::make_pair(xi_min[0], xi_max[0]),
+                                std::make_pair(xi_min[1], xi_max[1]),
+                                std::make_pair(xi_min[2], xi_max[2]),
+                                comp),
+                value_U);
+            } else {
+              raise::Error("Invalid dimension", HERE);
+            }
+          }
+        }
+      } else {
+        (void)direction;
+        (void)domain;
+        (void)tags;
+        raise::Error("Fixed fields not present (both const and non-const)", HERE);
+      }
+    }
+
+    template <class M>
+      requires metric::traits::HasD<M>
+    void PerfectConductorFieldsIn(dir::direction_t<M::Dim>     direction,
+                                  Domain<SimEngine::SRPIC, M>& domain,
+                                  BCTags                       tags) {
+      /**
+       * perfect conductor field boundaries
+       */
+      if constexpr (M::CoordType != Coord::Cart) {
+        (void)direction;
+        (void)domain;
+        (void)tags;
+        raise::Error(
+          "Perfect conductor BCs only applicable to cartesian coordinates",
+          HERE);
+      } else {
+        const auto sign = direction.get_sign();
+        const auto dim  = direction.get_dim();
+
+        std::vector<std::size_t> xi_min, xi_max;
+
+        const std::vector<in> all_dirs { in::x1, in::x2, in::x3 };
+
+        for (auto d { 0u }; d < M::Dim; ++d) {
+          const auto dd = all_dirs[d];
+          if (dim == dd) {
+            xi_min.push_back(0);
+            xi_max.push_back((sign < 0) ? (N_GHOSTS + 1) : N_GHOSTS);
+          } else {
+            xi_min.push_back(0);
+            xi_max.push_back(domain.mesh.n_all(dd));
+          }
+        }
+        raise::ErrorIf(xi_min.size() != xi_max.size() or
+                         xi_min.size() != static_cast<std::size_t>(M::Dim),
+                       "Invalid range size",
+                       HERE);
+
+        range_t<M::Dim> range;
+        if constexpr (M::Dim == Dim::_1D) {
+          range = CreateRangePolicy<M::Dim>({ xi_min[0] }, { xi_max[0] });
+        } else if constexpr (M::Dim == Dim::_2D) {
+          range = CreateRangePolicy<M::Dim>({ xi_min[0], xi_min[1] },
+                                            { xi_max[0], xi_max[1] });
+        } else if constexpr (M::Dim == Dim::_3D) {
+          range = CreateRangePolicy<M::Dim>({ xi_min[0], xi_min[1], xi_min[2] },
+                                            { xi_max[0], xi_max[1], xi_max[2] });
+        } else {
+          raise::Error("Invalid dimension", HERE);
+        }
+        std::size_t i_edge;
+        if (sign > 0) {
+          i_edge = domain.mesh.i_max(dim);
+        } else {
+          i_edge = domain.mesh.i_min(dim);
+        }
+
+        if (dim == in::x1) {
+          if (sign > 0) {
+            Kokkos::parallel_for(
+              "ConductorFields",
+              range,
+              kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x1, true>(
+                domain.fields.em,
+                i_edge,
+                tags));
+          } else {
+            Kokkos::parallel_for(
+              "ConductorFields",
+              range,
+              kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x1, false>(
+                domain.fields.em,
+                i_edge,
+                tags));
+          }
+        } else if (dim == in::x2) {
+          if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
+            if (sign > 0) {
+              Kokkos::parallel_for(
+                "ConductorFields",
+                range,
+                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x2, true>(
+                  domain.fields.em,
+                  i_edge,
+                  tags));
+            } else {
+              Kokkos::parallel_for(
+                "ConductorFields",
+                range,
+                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x2, false>(
+                  domain.fields.em,
+                  i_edge,
+                  tags));
+            }
+          } else {
+            raise::Error("Invalid dimension", HERE);
+          }
+        } else {
+          if constexpr (M::Dim == Dim::_3D) {
+            if (sign > 0) {
+              Kokkos::parallel_for(
+                "ConductorFields",
+                range,
+                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x3, true>(
+                  domain.fields.em,
+                  i_edge,
+                  tags));
+            } else {
+              Kokkos::parallel_for(
+                "ConductorFields",
+                range,
+                kernel::bc::ConductorBoundaries_kernel<M::Dim, in::x3, false>(
+                  domain.fields.em,
+                  i_edge,
+                  tags));
+            }
+          } else {
+            raise::Error("Invalid dimension", HERE);
+          }
+        }
+      }
+    }
+
+    template <class M, class PG>
+    void AtmosphereFieldsIn(dir::direction_t<M::Dim>     direction,
+                            Domain<SimEngine::SRPIC, M>& domain,
+                            const M&                     global_metric,
+                            const Grid<M::Dim>&          global_grid,
+                            const PG&                    pgen,
+                            const SimulationParams&      params,
+                            const prm::Parameters&       engine_params,
+                            BCTags                       tags) {
+      const auto time = engine_params.get<simtime_t>("time");
+      /**
+       * atmosphere field boundaries
+       */
+      if constexpr (arch::traits::pgen::HasAtmFields<PG>) {
+        const auto [sign, dim, xg_min, xg_max] = GetAtmosphereExtent(direction,
+                                                                     global_metric,
+                                                                     global_grid,
+                                                                     params);
+        // get_atm_extent(direction);
+        const auto           dd                = static_cast<dim_t>(dim);
+        boundaries_t<real_t> box;
+        boundaries_t<bool>   incl_ghosts;
+        for (auto d { 0u }; d < M::Dim; ++d) {
+          if (d == dd) {
+            box.push_back({ xg_min, xg_max });
+            if (sign > 0) {
+              incl_ghosts.push_back({ false, true });
+            } else {
+              incl_ghosts.push_back({ true, false });
+            }
+          } else {
+            box.push_back(Range::All);
+            incl_ghosts.push_back({ true, true });
+          }
+        }
+        if (not domain.mesh.Intersects(box)) {
+          return;
+        }
+        const auto intersect_range = domain.mesh.ExtentToRange(box, incl_ghosts);
+        tuple_t<std::size_t, M::Dim> range_min { 0 };
+        tuple_t<std::size_t, M::Dim> range_max { 0 };
+
+        for (auto d { 0u }; d < M::Dim; ++d) {
+          range_min[d] = intersect_range[d].first;
+          range_max[d] = intersect_range[d].second;
+        }
+        auto        atm_fields = pgen.AtmFields(time);
+        std::size_t il_edge;
+        if (sign > 0) {
+          il_edge = range_min[dd] - N_GHOSTS;
+        } else {
+          il_edge = range_max[dd] - 1 - N_GHOSTS;
+        }
+        const auto range = CreateRangePolicy<M::Dim>(range_min, range_max);
+        if (dim == in::x1) {
+          if (sign > 0) {
+            Kokkos::parallel_for(
+              "AtmosphereBCFields",
+              range,
+              kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x1>(
+                domain.fields.em,
+                atm_fields,
+                domain.mesh.metric,
+                il_edge,
+                tags));
+          } else {
+            Kokkos::parallel_for(
+              "AtmosphereBCFields",
+              range,
+              kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x1>(
+                domain.fields.em,
+                atm_fields,
+                domain.mesh.metric,
+                il_edge,
+                tags));
+          }
+        } else if (dim == in::x2) {
+          if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
+            if (sign > 0) {
+              Kokkos::parallel_for(
+                "AtmosphereBCFields",
+                range,
+                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x2>(
+                  domain.fields.em,
+                  atm_fields,
+                  domain.mesh.metric,
+                  il_edge,
+                  tags));
+            } else {
+              Kokkos::parallel_for(
+                "AtmosphereBCFields",
+                range,
+                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x2>(
+                  domain.fields.em,
+                  atm_fields,
+                  domain.mesh.metric,
+                  il_edge,
+                  tags));
+            }
+          } else {
+            raise::Error("Invalid dimension", HERE);
+          }
+        } else if (dim == in::x3) {
+          if constexpr (M::Dim == Dim::_3D) {
+            if (sign > 0) {
+              Kokkos::parallel_for(
+                "AtmosphereBCFields",
+                range,
+                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, true, in::x3>(
+                  domain.fields.em,
+                  atm_fields,
+                  domain.mesh.metric,
+                  il_edge,
+                  tags));
+            } else {
+              Kokkos::parallel_for(
+                "AtmosphereBCFields",
+                range,
+                kernel::bc::EnforcedBoundaries_kernel<decltype(atm_fields), M, false, in::x3>(
+                  domain.fields.em,
+                  atm_fields,
+                  domain.mesh.metric,
+                  il_edge,
+                  tags));
+            }
+          } else {
+            raise::Error("Invalid dimension", HERE);
+          }
+        } else {
+          raise::Error("Invalid dimension", HERE);
+        }
+      } else {
+        (void)direction;
+        (void)domain;
+        (void)tags;
+        raise::Error("Atm fields not implemented in PGEN for atmosphere BCs", HERE);
+      }
+    }
+
+    template <class M>
+      requires metric::traits::HasD<M>
+    void CustomFieldsIn(dir::direction_t<M::Dim>     direction,
+                        Domain<SimEngine::SRPIC, M>& domain,
+                        BCTags                       tags) {
+      (void)direction;
+      (void)domain;
+      (void)tags;
+      raise::Error("Custom boundaries not implemented", HERE);
+      // if constexpr (
+      //   traits::has_member<traits::pgen::custom_fields_t, pgen_t>::value) {
+      //   const auto [box, custom_fields] = m_pgen.CustomFields(time);
+      //   if (domain.mesh.Intersects(box)) {
+      //   }
+      //
+      // } else {
+      //   raise::Error("Custom boundaries not implemented", HERE);
+      // }
+    }
+
+    template <class M, class PG>
+      requires metric::traits::HasD<M>
+    void FieldBoundaries(Domain<SimEngine::SRPIC, M>& domain,
+                         const M&                     global_metric,
+                         const Grid<M::Dim>&          global_grid,
+                         const PG&                    pgen,
+                         const prm::Parameters&       engine_params,
+                         const SimulationParams&      params,
+                         BCTags                       tags) {
+      for (auto& direction : dir::Directions<M::Dim>::orth) {
+        if (global_grid.flds_bc_in(direction) == FldsBC::MATCH) {
+          MatchFieldsIn<M, PG>(direction,
+                               domain,
+                               global_grid,
+                               pgen,
+                               engine_params,
+                               params,
+                               tags);
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::AXIS) {
+          if (domain.mesh.flds_bc_in(direction) == FldsBC::AXIS) {
+            AxisFieldsIn<M>(direction, domain, tags);
+          }
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::ATMOSPHERE) {
+          AtmosphereFieldsIn<M, PG>(direction,
+                                    domain,
+                                    global_metric,
+                                    global_grid,
+                                    pgen,
+                                    params,
+                                    engine_params,
+                                    tags);
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::FIXED) {
+          if (domain.mesh.flds_bc_in(direction) == FldsBC::FIXED) {
+            FixedFieldsIn<M, PG>(direction, domain, pgen, engine_params, tags);
+          }
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::CONDUCTOR) {
+          if (domain.mesh.flds_bc_in(direction) == FldsBC::CONDUCTOR) {
+            PerfectConductorFieldsIn<M>(direction, domain, tags);
+          }
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::CUSTOM) {
+          if (domain.mesh.flds_bc_in(direction) == FldsBC::CUSTOM) {
+            CustomFieldsIn<M>(direction, domain, tags);
+          }
+        } else if (global_grid.flds_bc_in(direction) == FldsBC::HORIZON) {
+          raise::Error("HORIZON BCs only applicable for GR", HERE);
+        }
+      } // loop over directions
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif // ENGINES_SRPIC_FIELDS_BCS_H
diff --git a/src/engines/srpic/fieldsolvers.h b/src/engines/srpic/fieldsolvers.h
new file mode 100644
index 000000000..04bca2744
--- /dev/null
+++ b/src/engines/srpic/fieldsolvers.h
@@ -0,0 +1,193 @@
+#ifndef ENGINES_SRPIC_FIELDSOLVERS_H
+#define ENGINES_SRPIC_FIELDSOLVERS_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "utils/log.h"
+#include "utils/numeric.h"
+#include "utils/param_container.h"
+
+#include "archetypes/traits.h"
+#include "engines/srpic/utils.h"
+#include "framework/domain/domain.h"
+#include "framework/parameters/parameters.h"
+
+#include "kernels/ampere_mink.hpp"
+#include "kernels/ampere_sr.hpp"
+#include "kernels/faraday_mink.hpp"
+#include "kernels/faraday_sr.hpp"
+
+namespace ntt {
+  namespace srpic {
+
+    template <class M>
+    void Faraday(Domain<SimEngine::SRPIC, M>& domain,
+                 const prm::Parameters&       engine_params,
+                 const SimulationParams&      params,
+                 real_t                       fraction = ONE) {
+      logger::Checkpoint("Launching Faraday kernel", HERE);
+      const auto dt = engine_params.get<real_t>("dt");
+
+      const auto dT = fraction *
+                      params.template get<real_t>(
+                        "algorithms.timestep.correction") *
+                      dt;
+      if constexpr (M::CoordType == Coord::Cart) {
+        // minkowski case
+        const auto dx = math::sqrt(domain.mesh.metric.template h_<1, 1>({}));
+        const auto deltax = params.template get<real_t>(
+          "algorithms.fieldsolver.delta_x");
+        const auto deltay = params.template get<real_t>(
+          "algorithms.fieldsolver.delta_y");
+        const auto betaxy = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_xy");
+        const auto betayx = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_yx");
+        const auto deltaz = params.template get<real_t>(
+          "algorithms.fieldsolver.delta_z");
+        const auto betaxz = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_xz");
+        const auto betazx = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_zx");
+        const auto betayz = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_yz");
+        const auto betazy = params.template get<real_t>(
+          "algorithms.fieldsolver.beta_zy");
+        real_t coeff1, coeff2;
+        if constexpr (M::Dim == Dim::_2D) {
+          coeff1 = dT / SQR(dx);
+          coeff2 = dT;
+        } else {
+          coeff1 = dT / dx;
+          coeff2 = ZERO;
+        }
+        Kokkos::parallel_for("Faraday",
+                             domain.mesh.rangeActiveCells(),
+                             kernel::mink::Faraday_kernel<M::Dim>(domain.fields.em,
+                                                                  coeff1,
+                                                                  coeff2,
+                                                                  deltax,
+                                                                  deltay,
+                                                                  betaxy,
+                                                                  betayx,
+                                                                  deltaz,
+                                                                  betaxz,
+                                                                  betazx,
+                                                                  betayz,
+                                                                  betazy));
+      } else {
+        Kokkos::parallel_for("Faraday",
+                             domain.mesh.rangeActiveCells(),
+                             kernel::sr::Faraday_kernel<M>(domain.fields.em,
+                                                           domain.mesh.metric,
+                                                           dT,
+                                                           domain.mesh.flds_bc()));
+      }
+    }
+
+    template <class M>
+    void Ampere(Domain<SimEngine::SRPIC, M>& domain,
+                const prm::Parameters&       engine_params,
+                const SimulationParams&      params,
+                real_t                       fraction = ONE) {
+      logger::Checkpoint("Launching Ampere kernel", HERE);
+      const auto dt = engine_params.get<real_t>("dt");
+
+      const auto dT = fraction *
+                      params.template get<real_t>(
+                        "algorithms.timestep.correction") *
+                      dt;
+      auto range = RangeWithAxisBCs(domain);
+      if constexpr (M::CoordType == Coord::Cart) {
+        // minkowski case
+        const auto dx = math::sqrt(domain.mesh.metric.template h_<1, 1>({}));
+        real_t     coeff1, coeff2;
+        if constexpr (M::Dim == Dim::_2D) {
+          coeff1 = dT / SQR(dx);
+          coeff2 = dT;
+        } else {
+          coeff1 = dT / dx;
+          coeff2 = ZERO;
+        }
+
+        Kokkos::parallel_for(
+          "Ampere",
+          range,
+          kernel::mink::Ampere_kernel<M::Dim>(domain.fields.em, coeff1, coeff2));
+      } else {
+        const auto ni2 = domain.mesh.n_active(in::x2);
+        Kokkos::parallel_for("Ampere",
+                             range,
+                             kernel::sr::Ampere_kernel<M>(domain.fields.em,
+                                                          domain.mesh.metric,
+                                                          dT,
+                                                          ni2,
+                                                          domain.mesh.flds_bc()));
+      }
+    }
+
+    template <class M, class PG>
+    void CurrentsAmpere(Domain<SimEngine::SRPIC, M>& domain,
+                        const prm::Parameters&       engine_params,
+                        const SimulationParams&      params,
+                        const PG&                    pgen) {
+      logger::Checkpoint("Launching Ampere kernel for adding currents", HERE);
+      const auto dt = engine_params.get<real_t>("dt");
+
+      const auto q0 = params.template get<real_t>("scales.q0");
+      const auto n0 = params.template get<real_t>("scales.n0");
+      const auto B0 = params.template get<real_t>("scales.B0");
+      if constexpr (M::CoordType == Coord::Cart) {
+        // minkowski case
+        const auto V0    = params.template get<real_t>("scales.V0");
+        const auto ppc0  = params.template get<real_t>("particles.ppc0");
+        const auto coeff = -dt * q0 / (B0 * V0);
+        if constexpr (arch::traits::pgen::HasExtCurrent<PG>) {
+          const std::vector<real_t> xmin { domain.mesh.extent(in::x1).first,
+                                           domain.mesh.extent(in::x2).first,
+                                           domain.mesh.extent(in::x3).first };
+          const auto                ext_current = pgen.ext_current;
+          const auto dx = domain.mesh.metric.template sqrt_h_<1, 1>({});
+          Kokkos::parallel_for(
+            "Ampere",
+            domain.mesh.rangeActiveCells(),
+            kernel::mink::CurrentsAmpere_kernel<M::Dim, decltype(ext_current)>(
+              domain.fields.em,
+              domain.fields.cur,
+              coeff,
+              ppc0,
+              ext_current,
+              xmin,
+              dx));
+        } else {
+          Kokkos::parallel_for(
+            "Ampere",
+            domain.mesh.rangeActiveCells(),
+            kernel::mink::CurrentsAmpere_kernel<M::Dim>(domain.fields.em,
+                                                        domain.fields.cur,
+                                                        coeff,
+                                                        ppc0));
+        }
+      } else {
+        // non-minkowski
+        const auto coeff = -dt * q0 * n0 / B0;
+        auto       range = RangeWithAxisBCs(domain);
+        const auto ni2   = domain.mesh.n_active(in::x2);
+        Kokkos::parallel_for(
+          "Ampere",
+          range,
+          kernel::sr::CurrentsAmpere_kernel<M>(domain.fields.em,
+                                               domain.fields.cur,
+                                               domain.mesh.metric,
+                                               coeff,
+                                               ONE / n0,
+                                               ni2,
+                                               domain.mesh.flds_bc()));
+      }
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif // ENGINES_SRPIC_FIELDSOLVERS_H
diff --git a/src/engines/srpic/particle_pusher.h b/src/engines/srpic/particle_pusher.h
new file mode 100644
index 000000000..fc39c5b8f
--- /dev/null
+++ b/src/engines/srpic/particle_pusher.h
@@ -0,0 +1,327 @@
+#ifndef ENGINES_SRPIC_PARTICLE_PUSHER_H
+#define ENGINES_SRPIC_PARTICLE_PUSHER_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "utils/comparators.h"
+#include "utils/log.h"
+#include "utils/numeric.h"
+#include "utils/param_container.h"
+
+#include "metrics/traits.h"
+
+#include "archetypes/traits.h"
+#include "engines/srpic/utils.h"
+#include "framework/domain/domain.h"
+#include "framework/domain/grid.h"
+#include "framework/parameters/parameters.h"
+
+#include "kernels/emission/compton.hpp"
+#include "kernels/emission/synchrotron.hpp"
+#include "kernels/particle_pusher_sr.hpp"
+
+namespace ntt {
+  namespace srpic {
+
+    template <class M, class F = kernel::sr::NoForce_t>
+    void CallPusherWithExternalForce(Domain<SimEngine::SRPIC, M>& domain,
+                                     const SimulationParams&      params,
+                                     const kernel::sr::PusherParams& pusher_params,
+                                     kernel::sr::PusherArrays& pusher_arrays,
+                                     EmissionTypeFlag emission_policy_flag,
+                                     const range_t<Dim::_1D>&    range,
+                                     const ndfield_t<M::Dim, 6>& EB,
+                                     const M&                    metric,
+                                     const F&                    force) {
+      if (emission_policy_flag == EmissionType::NONE) {
+        Kokkos::parallel_for("ParticlePusher",
+                             range,
+                             kernel::sr::Pusher_kernel<M, F>(pusher_params,
+                                                             pusher_arrays,
+                                                             EB,
+                                                             metric,
+                                                             force));
+      } else if (emission_policy_flag == EmissionType::SYNCHROTRON) {
+        const auto photon_species = params.get<spidx_t>(
+          "radiation.emission.synchrotron.photon_species");
+        raise::ErrorIf(photon_species > domain.species.size(),
+                       "Invalid photon_species for Synchrotron emission",
+                       HERE);
+        auto& emitted_species = domain.species[photon_species - 1];
+        raise::ErrorIf(not cmp::AlmostZero_host(emitted_species.mass()),
+                       "Emitted photon species must have zero mass",
+                       HERE);
+        raise::ErrorIf(not cmp::AlmostZero_host(emitted_species.charge()),
+                       "Emitted photon species must have zero charge",
+                       HERE);
+        const auto emission_policy = kernel::emission::Synchrotron<M>(
+          emitted_species,
+          pusher_params.mass,
+          pusher_params.charge,
+          pusher_params.radiative_drag_flags,
+          pusher_params.dt,
+          domain.index(),
+          params,
+          domain.random_pool());
+        Kokkos::parallel_for(
+          "ParticlePusher",
+          range,
+          kernel::sr::Pusher_kernel<M, F, decltype(emission_policy)>(
+            pusher_params,
+            pusher_arrays,
+            EB,
+            metric,
+            force,
+            emission_policy));
+        const auto n_inj = emission_policy.number_injected();
+        domain.species[photon_species - 1].set_npart(
+          emitted_species.npart() + n_inj);
+        domain.species[photon_species - 1].set_counter(
+          emitted_species.counter() + n_inj);
+      } else if (emission_policy_flag == EmissionType::COMPTON) {
+        const auto photon_species = params.get<spidx_t>(
+          "radiation.emission.compton.photon_species");
+        raise::ErrorIf(photon_species > domain.species.size(),
+                       "Invalid photon_species for Compton emission",
+                       HERE);
+        auto& emitted_species = domain.species[photon_species - 1];
+        raise::ErrorIf(not cmp::AlmostZero_host(emitted_species.mass()),
+                       "Emitted photon species must have zero mass",
+                       HERE);
+        raise::ErrorIf(not cmp::AlmostZero_host(emitted_species.charge()),
+                       "Emitted photon species must have zero charge",
+                       HERE);
+        const auto emission_policy = kernel::emission::Compton<M>(
+          emitted_species,
+          pusher_params.mass,
+          pusher_params.charge,
+          pusher_params.radiative_drag_flags,
+          pusher_params.dt,
+          domain.index(),
+          params,
+          domain.random_pool());
+        Kokkos::parallel_for(
+          "ParticlePusher",
+          range,
+          kernel::sr::Pusher_kernel<M, F, decltype(emission_policy)>(
+            pusher_params,
+            pusher_arrays,
+            EB,
+            metric,
+            force,
+            emission_policy));
+        const auto n_inj = emission_policy.number_injected();
+        domain.species[photon_species - 1].set_npart(
+          emitted_species.npart() + n_inj);
+        domain.species[photon_species - 1].set_counter(
+          emitted_species.counter() + n_inj);
+      }
+    }
+
+    template <class M, class PG>
+      requires metric::traits::HasD<M>
+    void ParticlePush(Domain<SimEngine::SRPIC, M>& domain,
+                      const Grid<M::Dim>&          global_grid,
+                      const M&                     global_metric,
+                      const prm::Parameters&       engine_params,
+                      const SimulationParams&      params,
+                      const PG&                    pgen) {
+      const auto dt   = engine_params.get<real_t>("dt");
+      const auto time = engine_params.get<simtime_t>("time");
+
+      real_t gx1 { ZERO }, gx2 { ZERO }, gx3 { ZERO }, ds { ZERO };
+      real_t x_surf { ZERO };
+      bool   has_atmosphere = false;
+      for (auto& direction : dir::Directions<M::Dim>::orth) {
+        if (global_grid.prtl_bc_in(direction) == PrtlBC::ATMOSPHERE) {
+          raise::ErrorIf(has_atmosphere,
+                         "Only one direction is allowed to have atm boundaries",
+                         HERE);
+          has_atmosphere = true;
+          const auto g   = params.template get<real_t>(
+            "grid.boundaries.atmosphere.g");
+          ds = params.template get<real_t>("grid.boundaries.atmosphere.ds");
+          const auto [sign, dim, xg_min, xg_max] =
+            GetAtmosphereExtent(direction, global_metric, global_grid, params);
+          if (dim == in::x1) {
+            gx1 = sign > 0 ? g : -g;
+            gx2 = ZERO;
+            gx3 = ZERO;
+          } else if (dim == in::x2) {
+            gx1 = ZERO;
+            gx2 = sign > 0 ? g : -g;
+            gx3 = ZERO;
+          } else if (dim == in::x3) {
+            gx1 = ZERO;
+            gx2 = ZERO;
+            gx3 = sign > 0 ? g : -g;
+          } else {
+            raise::Error("Invalid dimension", HERE);
+          }
+          if (sign > 0) {
+            x_surf = xg_min;
+          } else {
+            x_surf = xg_max;
+          }
+        }
+      }
+      for (auto& species : domain.species) {
+        if ((species.pusher() == ParticlePusher::NONE) or (species.npart() == 0)) {
+          continue;
+        }
+        species.set_unsorted();
+        logger::Checkpoint(
+          fmt::format("Launching particle pusher kernel for %d [%s] : %lu",
+                      species.index(),
+                      species.label().c_str(),
+                      species.npart()),
+          HERE);
+
+        kernel::sr::PusherParams pusher_params {};
+        pusher_params.pusher_flags         = species.pusher();
+        pusher_params.radiative_drag_flags = species.radiative_drag_flags();
+        pusher_params.mass                 = species.mass();
+        pusher_params.charge               = species.charge();
+        pusher_params.time                 = time;
+        pusher_params.dt                   = dt;
+        pusher_params.omegaB0 = params.template get<real_t>("scales.omegaB0");
+        pusher_params.ni1     = domain.mesh.n_active(in::x1);
+        pusher_params.ni2     = domain.mesh.n_active(in::x2);
+        pusher_params.ni3     = domain.mesh.n_active(in::x3);
+        pusher_params.boundaries = domain.mesh.prtl_bc();
+
+        if (species.pusher() & ParticlePusher::GCA) {
+          pusher_params.gca_params.set(
+            "larmor_max",
+            params.template get<real_t>("algorithms.gca.larmor_max"));
+          pusher_params.gca_params.set(
+            "e_ovr_b_max",
+            params.template get<real_t>("algorithms.gca.e_ovr_b_max"));
+        }
+
+        if (species.radiative_drag_flags() & RadiativeDrag::SYNCHROTRON) {
+          pusher_params.radiative_drag_params.set(
+            "synchrotron_gamma_rad",
+            params.template get<real_t>(
+              "radiation.drag.synchrotron.gamma_rad"));
+        }
+
+        if (species.radiative_drag_flags() & RadiativeDrag::COMPTON) {
+          pusher_params.radiative_drag_params.set(
+            "compton_gamma_rad",
+            params.template get<real_t>("radiation.drag.compton.gamma_rad"));
+        }
+
+        kernel::sr::PusherArrays pusher_arrays {};
+        pusher_arrays.sp       = species.index();
+        pusher_arrays.i1       = species.i1;
+        pusher_arrays.i2       = species.i2;
+        pusher_arrays.i3       = species.i3;
+        pusher_arrays.i1_prev  = species.i1_prev;
+        pusher_arrays.i2_prev  = species.i2_prev;
+        pusher_arrays.i3_prev  = species.i3_prev;
+        pusher_arrays.dx1      = species.dx1;
+        pusher_arrays.dx2      = species.dx2;
+        pusher_arrays.dx3      = species.dx3;
+        pusher_arrays.dx1_prev = species.dx1_prev;
+        pusher_arrays.dx2_prev = species.dx2_prev;
+        pusher_arrays.dx3_prev = species.dx3_prev;
+        pusher_arrays.ux1      = species.ux1;
+        pusher_arrays.ux2      = species.ux2;
+        pusher_arrays.ux3      = species.ux3;
+        pusher_arrays.phi      = species.phi;
+        pusher_arrays.weight   = species.weight;
+        pusher_arrays.tag      = species.tag;
+
+        // toggle to indicate whether pgen defines the external force
+        bool has_extforce = false;
+        if constexpr (arch::traits::pgen::HasExtForce<PG>) {
+          has_extforce = true;
+          // toggle to indicate whether the ext force applies to current species
+          if (::traits::has_member<::traits::species_t, decltype(PG::ext_force)>::value) {
+            has_extforce &= std::find(pgen.ext_force.species.begin(),
+                                      pgen.ext_force.species.end(),
+                                      species.index()) !=
+                            pgen.ext_force.species.end();
+          }
+        }
+
+        pusher_params.ext_force = has_extforce;
+
+        if (not has_atmosphere and not has_extforce) {
+          CallPusherWithExternalForce<M>(domain,
+                                         params,
+                                         pusher_params,
+                                         pusher_arrays,
+                                         species.emission_policy_flag(),
+                                         species.rangeActiveParticles(),
+                                         domain.fields.em,
+                                         domain.mesh.metric,
+                                         kernel::sr::NoForce_t {});
+        } else if (has_atmosphere and not has_extforce) {
+          const auto force =
+            kernel::sr::Force<M::PrtlDim, M::CoordType, kernel::sr::NoForce_t, true> {
+              { gx1, gx2, gx3 },
+              x_surf,
+              ds
+          };
+          CallPusherWithExternalForce<M, decltype(force)>(
+            domain,
+            params,
+            pusher_params,
+            pusher_arrays,
+            species.emission_policy_flag(),
+            species.rangeActiveParticles(),
+            domain.fields.em,
+            domain.mesh.metric,
+            force);
+        } else if (not has_atmosphere and has_extforce) {
+          if constexpr (arch::traits::pgen::HasExtForce<PG>) {
+            const auto force =
+              kernel::sr::Force<M::PrtlDim, M::CoordType, decltype(pgen.ext_force), false> {
+                pgen.ext_force
+              };
+            CallPusherWithExternalForce<M, decltype(force)>(
+              domain,
+              params,
+              pusher_params,
+              pusher_arrays,
+              species.emission_policy_flag(),
+              species.rangeActiveParticles(),
+              domain.fields.em,
+              domain.mesh.metric,
+              force);
+          } else {
+            raise::Error("External force not implemented", HERE);
+          }
+        } else { // has_atmosphere and has_extforce
+          if constexpr (arch::traits::pgen::HasExtForce<PG>) {
+            const auto force =
+              kernel::sr::Force<M::PrtlDim, M::CoordType, decltype(pgen.ext_force), true> {
+                pgen.ext_force,
+                { gx1, gx2, gx3 },
+                x_surf,
+                ds
+            };
+            CallPusherWithExternalForce<M, decltype(force)>(
+              domain,
+              params,
+              pusher_params,
+              pusher_arrays,
+              species.emission_policy_flag(),
+              species.rangeActiveParticles(),
+              domain.fields.em,
+              domain.mesh.metric,
+              force);
+          } else {
+            raise::Error("External force not implemented", HERE);
+          }
+        }
+      }
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif // ENGINES_SRPIC_PARTICLE_PUSHER_H
diff --git a/src/engines/srpic/particles_bcs.h b/src/engines/srpic/particles_bcs.h
new file mode 100644
index 000000000..1f921f033
--- /dev/null
+++ b/src/engines/srpic/particles_bcs.h
@@ -0,0 +1,307 @@
+#ifndef ENGINES_SRPIC_PARTICLES_BCS_H
+#define ENGINES_SRPIC_PARTICLES_BCS_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "arch/directions.h"
+#include "utils/numeric.h"
+
+#include "metrics/traits.h"
+
+#include "archetypes/energy_dist.h"
+#include "archetypes/particle_injector.h"
+#include "archetypes/spatial_dist.h"
+#include "engines/srpic/utils.h"
+#include "framework/domain/domain.h"
+#include "framework/domain/metadomain.h"
+#include "framework/parameters/parameters.h"
+
+#include "kernels/particle_moments.hpp"
+
+namespace ntt {
+  namespace srpic {
+
+    template <class M>
+      requires metric::traits::HasD<M> && metric::traits::HasCoordType<M>
+    void AtmosphereParticlesIn(dir::direction_t<M::Dim>         direction,
+                               Metadomain<SimEngine::SRPIC, M>& metadomain,
+                               Domain<SimEngine::SRPIC, M>&     domain,
+                               const SimulationParams&          params,
+                               InjTags                          tags) {
+      const auto [sign, dim, xg_min, xg_max] = srpic::GetAtmosphereExtent(
+        direction,
+        metadomain.mesh().metric,
+        metadomain.mesh(),
+        params);
+
+      const auto x_surf = sign > 0 ? xg_min : xg_max;
+      const auto ds     = params.template get<real_t>(
+        "grid.boundaries.atmosphere.ds");
+      const auto temp = params.template get<real_t>(
+        "grid.boundaries.atmosphere.temperature");
+      const auto height = params.template get<real_t>(
+        "grid.boundaries.atmosphere.height");
+      const auto species = params.template get<std::pair<spidx_t, spidx_t>>(
+        "grid.boundaries.atmosphere.species");
+      const auto nmax = params.template get<real_t>(
+        "grid.boundaries.atmosphere.density");
+
+      Kokkos::deep_copy(domain.fields.bckp, ZERO);
+      auto scatter_bckp = Kokkos::Experimental::create_scatter_view(
+        domain.fields.bckp);
+      const auto use_weights = M::CoordType != Coord::Cart;
+      const auto ni2         = domain.mesh.n_active(in::x2);
+      const auto inv_n0      = ONE / params.template get<real_t>("scales.n0");
+
+      // compute the density of the two species
+      if (tags & Inj::AssumeEmpty) {
+        if constexpr (M::Dim == Dim::_1D) {
+          Kokkos::deep_copy(
+            Kokkos::subview(domain.fields.bckp, Kokkos::ALL, std::make_pair(0, 1)),
+            ZERO);
+        } else if constexpr (M::Dim == Dim::_2D) {
+          Kokkos::deep_copy(Kokkos::subview(domain.fields.bckp,
+                                            Kokkos::ALL,
+                                            Kokkos::ALL,
+                                            std::make_pair(0, 1)),
+                            ZERO);
+        } else if constexpr (M::Dim == Dim::_3D) {
+          Kokkos::deep_copy(Kokkos::subview(domain.fields.bckp,
+                                            Kokkos::ALL,
+                                            Kokkos::ALL,
+                                            Kokkos::ALL,
+                                            std::make_pair(0, 1)),
+                            ZERO);
+        }
+      } else {
+        for (const auto& sp :
+             std::vector<spidx_t> { species.first, species.second }) {
+          auto& prtl_spec = domain.species[sp - 1];
+          if (prtl_spec.npart() == 0) {
+            continue;
+          }
+          // clang-format off
+          Kokkos::parallel_for(
+            "ComputeMoments",
+            prtl_spec.rangeActiveParticles(),
+            kernel::ParticleMoments_kernel<SimEngine::SRPIC, M, FldsID::Rho, 6>(
+              {}, scatter_bckp, 0,
+              prtl_spec.i1, prtl_spec.i2, prtl_spec.i3,
+              prtl_spec.dx1, prtl_spec.dx2, prtl_spec.dx3,
+              prtl_spec.ux1, prtl_spec.ux2, prtl_spec.ux3,
+              prtl_spec.phi, prtl_spec.weight, prtl_spec.tag,
+              prtl_spec.mass(), prtl_spec.charge(),
+              use_weights,
+              domain.mesh.metric, domain.mesh.flds_bc(),
+              ni2, inv_n0, 0));
+          // clang-format on
+          prtl_spec.set_unsorted();
+        }
+        Kokkos::Experimental::contribute(domain.fields.bckp, scatter_bckp);
+        metadomain.SynchronizeFields(domain, Comm::Bckp, { 0, 1 });
+      }
+
+      const auto maxwellian = arch::Maxwellian<SimEngine::SRPIC, M> {
+        domain.mesh.metric,
+        domain.random_pool(),
+        temp
+      };
+
+      if (dim == in::x1) {
+        if (sign > 0) {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x1> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        } else {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x1> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        }
+      } else if (dim == in::x2) {
+        if (sign > 0) {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x2> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        } else {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x2> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        }
+      } else if (dim == in::x3) {
+        if (sign > 0) {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, true, in::x3> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        } else {
+          auto target_density =
+            arch::AtmosphereDensityProfile<M::Dim, M::CoordType, false, in::x3> {
+              nmax,
+              height,
+              x_surf,
+              ds
+            };
+          const auto spatial_dist =
+            arch::Replenish<SimEngine::SRPIC, M, 6, decltype(target_density)> {
+              domain.mesh.metric,
+              domain.fields.bckp,
+              0,
+              target_density,
+              nmax
+            };
+          arch::InjectNonUniform<SimEngine::SRPIC,
+                                 M,
+                                 decltype(maxwellian),
+                                 decltype(maxwellian),
+                                 decltype(spatial_dist)>(
+            params,
+            domain,
+            { species.first, species.second },
+            { maxwellian, maxwellian },
+            spatial_dist,
+            nmax,
+            use_weights);
+        }
+      } else {
+        raise::Error("Invalid dimension", HERE);
+      }
+      return;
+    }
+
+    template <class M>
+      requires metric::traits::HasD<M>
+    void ParticleInjector(Metadomain<SimEngine::SRPIC, M>& metadomain,
+                          Domain<SimEngine::SRPIC, M>&     domain,
+                          const SimulationParams&          params,
+                          InjTags                          tags = Inj::None) {
+      for (auto& direction : dir::Directions<M::Dim>::orth) {
+        if (metadomain.mesh().prtl_bc_in(direction) == PrtlBC::ATMOSPHERE) {
+          AtmosphereParticlesIn(direction, metadomain, domain, params, tags);
+        }
+      }
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif
diff --git a/src/engines/srpic/srpic.hpp b/src/engines/srpic/srpic.hpp
new file mode 100644
index 000000000..e09e07a11
--- /dev/null
+++ b/src/engines/srpic/srpic.hpp
@@ -0,0 +1,199 @@
+/**
+ * @file engines/srpic.hpp
+ * @brief Simulation engien class which specialized on SRPIC
+ * @implements
+ *   - ntt::SRPICEngine<> : ntt::Engine<>
+ * @cpp:
+ *   - srpic.cpp
+ * @namespaces:
+ *   - ntt::
+ * @macros:
+ */
+
+#ifndef ENGINES_SRPIC_SRPIC_H
+#define ENGINES_SRPIC_SRPIC_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "utils/numeric.h"
+#include "utils/timer.h"
+#include <toml11/toml.hpp>
+
+#include "engines/srpic/currents.h"
+#include "engines/srpic/fields_bcs.h"
+#include "engines/srpic/fieldsolvers.h"
+#include "engines/srpic/particle_pusher.h"
+#include "engines/srpic/particles_bcs.h"
+#include "engines/traits.h"
+#include "framework/domain/domain.h"
+#include "framework/parameters/parameters.h"
+
+#include "engines/engine.hpp"
+#include "pgen.hpp"
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_ScatterView.hpp>
+
+namespace ntt {
+
+  template <class M>
+    requires traits::engine::IsCompatibleWithSRPICEngine<M, user::PGen>
+  class SRPICEngine : public Engine<SimEngine::SRPIC, M> {
+
+    using base_t   = Engine<SimEngine::SRPIC, M>;
+    using pgen_t   = user::PGen<SimEngine::SRPIC, M>;
+    using domain_t = Domain<SimEngine::SRPIC, M>;
+    // contents
+    using base_t::m_metadomain;
+    using base_t::m_params;
+    using base_t::m_pgen;
+    // methods
+    using base_t::init;
+    // variables
+    using base_t::dt;
+    using base_t::max_steps;
+    using base_t::runtime;
+    using base_t::step;
+    using base_t::time;
+
+  public:
+    static constexpr auto S { SimEngine::SRPIC };
+
+    SRPICEngine(const SimulationParams& params) : base_t { params } {}
+
+    ~SRPICEngine() = default;
+
+    void step_forward(timer::Timers& timers, domain_t& dom) override {
+      const auto fieldsolver_enabled = m_params.template get<bool>(
+        "algorithms.fieldsolver.enable");
+      const auto deposit_enabled = m_params.template get<bool>(
+        "algorithms.deposit.enable");
+      const auto clear_interval = m_params.template get<std::size_t>(
+        "particles.clear_interval");
+
+      if (step == 0) {
+        // communicate fields and apply BCs on the first timestep
+        m_metadomain.CommunicateFields(dom, Comm::B | Comm::E);
+        srpic::FieldBoundaries(dom,
+                               m_metadomain.mesh().metric,
+                               m_metadomain.mesh(),
+                               m_pgen,
+                               this->engineParams(),
+                               m_params,
+                               BC::B | BC::E);
+        srpic::ParticleInjector(m_metadomain, dom, m_params);
+      }
+
+      if (fieldsolver_enabled) {
+        timers.start("FieldSolver");
+        srpic::Faraday(dom, this->engineParams(), m_params, HALF);
+        timers.stop("FieldSolver");
+
+        timers.start("Communications");
+        m_metadomain.CommunicateFields(dom, Comm::B);
+        timers.stop("Communications");
+
+        timers.start("FieldBoundaries");
+        srpic::FieldBoundaries(dom,
+                               m_metadomain.mesh().metric,
+                               m_metadomain.mesh(),
+                               m_pgen,
+                               this->engineParams(),
+                               m_params,
+                               BC::B);
+        timers.stop("FieldBoundaries");
+        Kokkos::fence();
+      }
+
+      {
+        timers.start("ParticlePusher");
+        srpic::ParticlePush(dom,
+                            m_metadomain.mesh(),
+                            m_metadomain.mesh().metric,
+                            this->engineParams(),
+                            m_params,
+                            m_pgen);
+        timers.stop("ParticlePusher");
+
+        if (deposit_enabled) {
+          timers.start("CurrentDeposit");
+          srpic::CurrentsDeposit(dom, this->engineParams());
+          timers.stop("CurrentDeposit");
+
+          timers.start("Communications");
+          m_metadomain.SynchronizeFields(dom, Comm::J);
+          m_metadomain.CommunicateFields(dom, Comm::J);
+          timers.stop("Communications");
+
+          timers.start("CurrentFiltering");
+          srpic::CurrentsFilter(m_metadomain, dom, m_params);
+          timers.stop("CurrentFiltering");
+        }
+
+        timers.start("Communications");
+        m_metadomain.CommunicateParticles(dom);
+        timers.stop("Communications");
+      }
+
+      if (fieldsolver_enabled) {
+        timers.start("FieldSolver");
+        srpic::Faraday(dom, this->engineParams(), m_params, HALF);
+        timers.stop("FieldSolver");
+
+        timers.start("Communications");
+        m_metadomain.CommunicateFields(dom, Comm::B);
+        timers.stop("Communications");
+
+        timers.start("FieldBoundaries");
+        srpic::FieldBoundaries(dom,
+                               m_metadomain.mesh().metric,
+                               m_metadomain.mesh(),
+                               m_pgen,
+                               this->engineParams(),
+                               m_params,
+                               BC::B);
+        timers.stop("FieldBoundaries");
+
+        timers.start("FieldSolver");
+        srpic::Ampere(dom, this->engineParams(), m_params, ONE);
+        timers.stop("FieldSolver");
+
+        if (deposit_enabled) {
+          timers.start("FieldSolver");
+          srpic::CurrentsAmpere(dom, this->engineParams(), m_params, m_pgen);
+          timers.stop("FieldSolver");
+        }
+
+        timers.start("Communications");
+        m_metadomain.CommunicateFields(dom, Comm::E | Comm::J);
+        timers.stop("Communications");
+
+        timers.start("FieldBoundaries");
+        srpic::FieldBoundaries(dom,
+                               m_metadomain.mesh().metric,
+                               m_metadomain.mesh(),
+                               m_pgen,
+                               this->engineParams(),
+                               m_params,
+                               BC::E);
+        timers.stop("FieldBoundaries");
+      }
+
+      {
+        timers.start("Injector");
+        srpic::ParticleInjector(m_metadomain, dom, m_params);
+        timers.stop("Injector");
+      }
+
+      if (clear_interval > 0 and step % clear_interval == 0 and step > 0) {
+        timers.start("PrtlClear");
+        m_metadomain.RemoveDeadParticles(dom);
+        timers.stop("PrtlClear");
+      }
+    }
+  };
+
+} // namespace ntt
+
+#endif // ENGINES_SRPIC_SRPIC_H
diff --git a/src/engines/srpic/utils.h b/src/engines/srpic/utils.h
new file mode 100644
index 000000000..9779e55e4
--- /dev/null
+++ b/src/engines/srpic/utils.h
@@ -0,0 +1,127 @@
+#ifndef ENGINES_SRPIC_UTILS_H
+#define ENGINES_SRPIC_UTILS_H
+
+#include "enums.h"
+#include "global.h"
+
+#include "arch/directions.h"
+#include "utils/numeric.h"
+
+#include "metrics/traits.h"
+
+#include "framework/domain/domain.h"
+#include "framework/domain/grid.h"
+#include "framework/parameters/parameters.h"
+
+#include <tuple>
+
+namespace ntt {
+  namespace srpic {
+
+    /**
+     * @brief Get the buffer region of the atmosphere and the direction
+     * @param direction direction in which the atmosphere is applied
+     * @return tuple: [sign of the direction, the direction (as in::), the min and max extent
+     * @note xg_min and xg_max are the extents where the fields are set, not the atmosphere itself
+     * @note i.e.
+     *
+     *         fields set      particles injected
+     * ghost zone  |               |
+     *    v        v               v
+     * |....|...........|*******************.....  -> x1
+     * ^                ^
+     * xg_min         xg_max
+     * |                |                  |
+     * |<--  buffer  -->|<-- atmosphere -->|
+     *
+     * in this case the function returns { -1, in::x1, xg_min, xg_max }
+     */
+    template <class M>
+      requires metric::traits::HasD<M> && metric::traits::HasConvert<M>
+    auto GetAtmosphereExtent(dir::direction_t<M::Dim> direction,
+                             const M&                 global_metric,
+                             const Grid<M::Dim>&      global_grid,
+                             const SimulationParams&  params)
+      -> std::tuple<short, in, real_t, real_t> {
+      const auto sign     = direction.get_sign();
+      const auto dim      = direction.get_dim();
+      const auto min_buff = params.template get<unsigned short>(
+                              "algorithms.current_filters") +
+                            2;
+      const auto buffer_ncells = min_buff > 5 ? min_buff : 5;
+      if (M::CoordType != Coord::Cart and (dim != in::x1 or sign > 0)) {
+        raise::Error("For non-cartesian coordinates atmosphere BCs is "
+                     "possible only in -x1 (@ rmin)",
+                     HERE);
+      }
+      real_t   xg_min { ZERO }, xg_max { ZERO };
+      ncells_t ig_min, ig_max;
+      if (sign > 0) { // + direction
+        ig_min = global_grid.n_active(dim) - buffer_ncells;
+        ig_max = global_grid.n_active(dim);
+      } else { // - direction
+        ig_min = 0;
+        ig_max = buffer_ncells;
+      }
+
+      if (dim == in::x1) {
+        xg_min = global_metric.template convert<1, Crd::Cd, Crd::Ph>(
+          static_cast<real_t>(ig_min));
+        xg_max = global_metric.template convert<1, Crd::Cd, Crd::Ph>(
+          static_cast<real_t>(ig_max));
+      } else if (dim == in::x2) {
+        if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
+          xg_min = global_metric.template convert<2, Crd::Cd, Crd::Ph>(
+            static_cast<real_t>(ig_min));
+          xg_max = global_metric.template convert<2, Crd::Cd, Crd::Ph>(
+            static_cast<real_t>(ig_max));
+        } else {
+          raise::Error("Invalid dimension", HERE);
+        }
+      } else if (dim == in::x3) {
+        if constexpr (M::Dim == Dim::_3D) {
+          xg_min = global_metric.template convert<3, Crd::Cd, Crd::Ph>(
+            static_cast<real_t>(ig_min));
+          xg_max = global_metric.template convert<3, Crd::Cd, Crd::Ph>(
+            static_cast<real_t>(ig_max));
+        } else {
+          raise::Error("Invalid dimension", HERE);
+        }
+      } else {
+        raise::Error("Invalid dimension", HERE);
+      }
+      return { sign, dim, xg_min, xg_max };
+    }
+
+    template <class M>
+    auto RangeWithAxisBCs(const Domain<SimEngine::SRPIC, M>& domain)
+      -> range_t<M::Dim> {
+      auto range = domain.mesh.rangeActiveCells();
+      if constexpr (M::CoordType != Coord::Cart) {
+        /**
+         * @brief taking one extra cell in the x2 direction if AXIS BCs
+         */
+        if constexpr (M::Dim == Dim::_2D) {
+          if (domain.mesh.flds_bc_in({ 0, +1 }) == FldsBC::AXIS) {
+            range = CreateRangePolicy<Dim::_2D>(
+              { domain.mesh.i_min(in::x1), domain.mesh.i_min(in::x2) },
+              { domain.mesh.i_max(in::x1), domain.mesh.i_max(in::x2) + 1 });
+          }
+        } else if constexpr (M::Dim == Dim::_3D) {
+          if (domain.mesh.flds_bc_in({ 0, +1, 0 }) == FldsBC::AXIS) {
+            range = CreateRangePolicy<Dim::_3D>({ domain.mesh.i_min(in::x1),
+                                                  domain.mesh.i_min(in::x2),
+                                                  domain.mesh.i_min(in::x3) },
+                                                { domain.mesh.i_max(in::x1),
+                                                  domain.mesh.i_max(in::x2) + 1,
+                                                  domain.mesh.i_max(in::x3) });
+          }
+        }
+      }
+      return range;
+    }
+
+  } // namespace srpic
+} // namespace ntt
+
+#endif
diff --git a/src/engines/traits.h b/src/engines/traits.h
new file mode 100644
index 000000000..4050049b5
--- /dev/null
+++ b/src/engines/traits.h
@@ -0,0 +1,56 @@
+/**
+ * @file engine/traits.h
+ * @brief Defines a set of traits to check if an engine class satisfies certain
+ * conditions
+ * @implements
+ *  - ntt::traits::engine::HasRun<> - checks if an engine has a run() method
+ *  - ntt::traits::engine::IsCompatibleWithEngine<> - checks if a metric and
+ * pgen are compatible with a given simulation engine
+ *  - ntt::traits::engine::IsCompatibleWithSRPICEngine<> - checks if a metric
+ * and pgen are compatible with the SRPIC engine
+ *  - ntt::traits::engine::IsCompatibleWithGRPICEngine<> - checks if a metric
+ * and pgen are compatible with the GRPIC engine
+ * @namespaces:
+ *   - ntt::traits::engine::
+ */
+#ifndef ENGINES_TRAITS_H
+#define ENGINES_TRAITS_H
+
+#include "metrics/traits.h"
+
+#include "archetypes/traits.h"
+
+#include <concepts>
+
+namespace ntt {
+  namespace traits {
+    namespace engine {
+
+      template <SimEngine::type S, class M, template <SimEngine::type, class> class PG>
+      concept IsCompatibleWithEngine =
+        metric::traits::HasD<M> and
+        arch::traits::pgen::check_compatibility<S>::value(PG<S, M>::engines) and
+        arch::traits::pgen::check_compatibility<M::MetricType>::value(
+          PG<S, M>::metrics) and
+        arch::traits::pgen::check_compatibility<M::Dim>::value(PG<S, M>::dimensions);
+
+      template <class M, template <SimEngine::type, class> class PG>
+      concept IsCompatibleWithSRPICEngine =
+        IsCompatibleWithEngine<SimEngine::SRPIC, M, PG> &&
+        metric::traits::HasH_ij<M> && metric::traits::HasConvert_i<M> &&
+        metric::traits::HasSqrtH_ij<M>;
+
+      template <class M, template <SimEngine::type, class> class PG>
+      concept IsCompatibleWithGRPICEngine =
+        IsCompatibleWithEngine<SimEngine::GRPIC, M, PG>;
+
+      template <class E>
+      concept HasRun = requires(E& engine) {
+        { engine.run() } -> std::same_as<void>;
+      };
+
+    } // namespace engine
+  } // namespace traits
+} // namespace ntt
+
+#endif // ENGINES_TRAITS_H
diff --git a/src/entity.cpp b/src/entity.cpp
index 8d88e2654..9afb37cb2 100644
--- a/src/entity.cpp
+++ b/src/entity.cpp
@@ -3,19 +3,39 @@
 #include "arch/traits.h"
 #include "utils/error.h"
 
-#include "engines/engine_traits.h"
+#include "archetypes/traits.h"
 #include "framework/simulation.h"
 #include "framework/specialization_registry.h"
 
+#include "engines/grpic.hpp"
+#include "engines/srpic/srpic.hpp"
 #include "pgen.hpp"
- 
+
 #include <type_traits>
 
+namespace ntt {
+  template <SimEngine::type S>
+  struct EngineSelector;
+
+  template <>
+  struct EngineSelector<SimEngine::SRPIC> {
+    template <class M>
+    using type = SRPICEngine<M>;
+  };
+
+  template <>
+  struct EngineSelector<SimEngine::GRPIC> {
+    template <class M>
+    using type = GRPICEngine<M>;
+  };
+} // namespace ntt
+
 template <ntt::SimEngine::type S, template <Dimension> class M, Dimension D>
 static constexpr bool should_compile {
-  traits::check_compatibility<S>::value(user::PGen<S, M<D>>::engines) &&
-  traits::check_compatibility<M<D>::MetricType>::value(user::PGen<S, M<D>>::metrics) &&
-  traits::check_compatibility<D>::value(user::PGen<S, M<D>>::dimensions)
+  arch::traits::pgen::check_compatibility<S>::value(user::PGen<S, M<D>>::engines) &&
+  arch::traits::pgen::check_compatibility<M<D>::MetricType>::value(
+    user::PGen<S, M<D>>::metrics) &&
+  arch::traits::pgen::check_compatibility<D>::value(user::PGen<S, M<D>>::dimensions)
 };
 
 template <ntt::SimEngine::type S, template <Dimension> class M, Dimension D>
@@ -26,7 +46,7 @@ void dispatch_engine(ntt::Simulation& sim) {
     sim.run<ntt::EngineSelector<S>::template type, M, D>();
   } else {
     static_assert(
-      traits::always_false<std::integral_constant<SimEngine::type, S>>::value,
+      ::traits::always_false<std::integral_constant<SimEngine::type, S>>::value,
       "Unsupported engine");
   }
 }
diff --git a/src/framework/CMakeLists.txt b/src/framework/CMakeLists.txt
index 014967870..c92b02d39 100644
--- a/src/framework/CMakeLists.txt
+++ b/src/framework/CMakeLists.txt
@@ -4,7 +4,12 @@
 #
 # @sources:
 #
-# * parameters.cpp
+# * parameters/parameters.cpp
+# * parameters/particles.cpp
+# * parameters/grid.cpp
+# * parameters/output.cpp
+# * parameters/algorithms.cpp
+# * parameters/extra.cpp
 # * simulation.cpp
 # * domain/grid.cpp
 # * domain/metadomain.cpp
@@ -36,8 +41,13 @@
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(SOURCES
-    ${SRC_DIR}/parameters.cpp
     ${SRC_DIR}/simulation.cpp
+    ${SRC_DIR}/parameters/parameters.cpp
+    ${SRC_DIR}/parameters/particles.cpp
+    ${SRC_DIR}/parameters/grid.cpp
+    ${SRC_DIR}/parameters/output.cpp
+    ${SRC_DIR}/parameters/algorithms.cpp
+    ${SRC_DIR}/parameters/extra.cpp
     ${SRC_DIR}/domain/grid.cpp
     ${SRC_DIR}/domain/metadomain.cpp
     ${SRC_DIR}/domain/communications.cpp
@@ -58,7 +68,9 @@ add_library(ntt_framework ${SOURCES})
 set(libs ntt_global ntt_metrics ntt_kernels ntt_output)
 add_dependencies(ntt_framework ${libs})
 target_link_libraries(ntt_framework PUBLIC ${libs})
-target_link_libraries(ntt_framework PRIVATE stdc++fs)
+if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+  target_link_libraries(ntt_framework PRIVATE stdc++fs)
+endif()
 
 target_include_directories(
   ntt_framework
diff --git a/src/framework/containers/particles.cpp b/src/framework/containers/particles.cpp
index e9e516221..b1b774972 100644
--- a/src/framework/containers/particles.cpp
+++ b/src/framework/containers/particles.cpp
@@ -16,26 +16,26 @@
 
 namespace ntt {
   template <Dimension D, Coord::type C>
-  Particles<D, C>::Particles(spidx_t            index,
-                             const std::string& label,
-                             float              m,
-                             float              ch,
-                             npart_t            maxnpart,
-                             const PrtlPusher&  pusher,
-                             bool               use_tracking,
-                             bool               use_gca,
-                             const Cooling&     cooling,
-                             unsigned short     npld_r,
-                             unsigned short     npld_i)
+  Particles<D, C>::Particles(spidx_t             index,
+                             const std::string&  label,
+                             float               m,
+                             float               ch,
+                             npart_t             maxnpart,
+                             ParticlePusherFlags particle_pusher_flags,
+                             bool                use_tracking,
+                             RadiativeDragFlags  radiative_drag_flags,
+                             EmissionTypeFlag    emission_policy_flag,
+                             unsigned short      npld_r,
+                             unsigned short      npld_i)
     : ParticleSpecies(index,
                       label,
                       m,
                       ch,
                       maxnpart,
-                      pusher,
+                      particle_pusher_flags,
                       use_tracking,
-                      use_gca,
-                      cooling,
+                      radiative_drag_flags,
+                      emission_policy_flag,
                       npld_r,
                       npld_i) {
 
diff --git a/src/framework/containers/particles.h b/src/framework/containers/particles.h
index 144ca611c..f265425ea 100644
--- a/src/framework/containers/particles.h
+++ b/src/framework/containers/particles.h
@@ -83,24 +83,24 @@ namespace ntt {
      * @param m The mass of the species
      * @param ch The charge of the species
      * @param maxnpart The maximum number of allocated particles for the species
-     * @param pusher The pusher assigned for the species
+     * @param particle_pusher_flags The pusher(s) assigned for the species
      * @param use_tracking Use particle tracking for the species
-     * @param use_gca Use hybrid GCA pusher for the species
-     * @param cooling The cooling mechanism assigned for the species
+     * @param radiative_drag_flags The radiative drag mechanism(s) assigned for the species
+     * @param emission_policy_flag The emission policy assigned for the species
      * @param npld_r The number of real-valued payloads for the species
      * @param npld_i The number of integer-valued payloads for the species
      */
-    Particles(spidx_t            index,
-              const std::string& label,
-              float              m,
-              float              ch,
-              npart_t            maxnpart,
-              const PrtlPusher&  pusher,
-              bool               use_gca,
-              bool               use_tracking,
-              const Cooling&     cooling,
-              unsigned short     npld_r = 0,
-              unsigned short     npld_i = 0);
+    Particles(spidx_t             index,
+              const std::string&  label,
+              float               m,
+              float               ch,
+              npart_t             maxnpart,
+              ParticlePusherFlags particle_pusher_flags,
+              bool                use_tracking,
+              RadiativeDragFlags  radiative_drag_flags,
+              EmissionTypeFlag    emission_policy_flag,
+              unsigned short      npld_r,
+              unsigned short      npld_i);
 
     /**
      * @brief Constructor for the particle container
@@ -115,8 +115,8 @@ namespace ntt {
                   spec.maxnpart(),
                   spec.pusher(),
                   spec.use_tracking(),
-                  spec.use_gca(),
-                  spec.cooling(),
+                  spec.radiative_drag_flags(),
+                  spec.emission_policy_flag(),
                   spec.npld_r(),
                   spec.npld_i()) {}
 
diff --git a/src/framework/containers/particles_io.cpp b/src/framework/containers/particles_io.cpp
index 8efff59ac..2dc1bf215 100644
--- a/src/framework/containers/particles_io.cpp
+++ b/src/framework/containers/particles_io.cpp
@@ -403,9 +403,9 @@ namespace ntt {
                               { adios2::UnknownDim });
     if (npld_r() > 0) {
       io.DefineVariable<real_t>(fmt::format("s%d_pld_r", index()),
-                                { adios2::UnknownDim, npld_r() },
-                                { adios2::UnknownDim, 0 },
-                                { adios2::UnknownDim, npld_r() });
+                                { adios2::UnknownDim },
+                                { adios2::UnknownDim },
+                                { adios2::UnknownDim });
     }
     if (npld_i() > 0) {
       io.DefineVariable<npart_t>(fmt::format("s%d_pld_i", index()),
diff --git a/src/framework/containers/species.h b/src/framework/containers/species.h
index baf024874..8297dcdb5 100644
--- a/src/framework/containers/species.h
+++ b/src/framework/containers/species.h
@@ -13,6 +13,9 @@
 
 #include "enums.h"
 
+#include "utils/formatting.h"
+#include "utils/reporter.h"
+
 #include <string>
 
 namespace ntt {
@@ -31,16 +34,16 @@ namespace ntt {
     npart_t           m_maxnpart;
 
     // Pusher assigned for the species
-    const PrtlPusher m_pusher;
+    const ParticlePusherFlags m_particle_pusher_flags;
 
     // Use particle tracking for the species
     const bool m_use_tracking;
 
-    // Use byrid gca pusher for the species
-    const bool m_use_gca;
+    // Radiative drag mechanism(s) assigned for the species
+    const RadiativeDragFlags m_radiative_drag_flags;
 
-    // Cooling drag mechanism assigned for the species
-    const Cooling m_cooling;
+    // Emission policy assigned for the species
+    const EmissionTypeFlag m_emission_policy_flag;
 
     // Number of payloads for the species
     const unsigned short m_npld_r;
@@ -53,10 +56,10 @@ namespace ntt {
       , m_mass { 0.0 }
       , m_charge { 0.0 }
       , m_maxnpart { 0 }
-      , m_pusher { PrtlPusher::INVALID }
+      , m_particle_pusher_flags { ParticlePusher::NONE }
       , m_use_tracking { false }
-      , m_use_gca { false }
-      , m_cooling { Cooling::INVALID }
+      , m_radiative_drag_flags { RadiativeDrag::NONE }
+      , m_emission_policy_flag { EmissionType::NONE }
       , m_npld_r { 0 }
       , m_npld_i { 0 } {}
 
@@ -68,33 +71,33 @@ namespace ntt {
      * @param m The mass of the species.
      * @param ch The charge of the species.
      * @param maxnpart The maximum number of allocated particles for the species.
-     * @param pusher The pusher assigned for the species.
+     * @param particle_pusher_flags The pusher(s) assigned for the species.
      * @param use_tracking Use particle tracking for the species.
-     * @param use_gca Use hybrid GCA pusher for the species.
-     * @param cooling The cooling mechanism assigned for the species.
+     * @param radiative_drag_flags The radiative drag mechanism(s) assigned for the species.
+     * @param emission_policy_flag The emission policy assigned for the species.
      * @param npld_r The number of real-valued payloads for the species
      * @param npld_i The number of integer-valued payloads for the species
      */
-    ParticleSpecies(spidx_t            index,
-                    const std::string& label,
-                    float              m,
-                    float              ch,
-                    npart_t            maxnpart,
-                    const PrtlPusher&  pusher,
-                    bool               use_tracking,
-                    bool               use_gca,
-                    const Cooling&     cooling,
-                    unsigned short     npld_r = 0,
-                    unsigned short     npld_i = 0)
+    ParticleSpecies(spidx_t             index,
+                    const std::string&  label,
+                    float               m,
+                    float               ch,
+                    npart_t             maxnpart,
+                    ParticlePusherFlags particle_pusher_flags,
+                    bool                use_tracking,
+                    RadiativeDragFlags  radiative_drag_flags,
+                    EmissionTypeFlag    emission_policy_flag,
+                    unsigned short      npld_r,
+                    unsigned short      npld_i)
       : m_index { index }
       , m_label { std::move(label) }
       , m_mass { m }
       , m_charge { ch }
       , m_maxnpart { maxnpart }
-      , m_pusher { pusher }
+      , m_particle_pusher_flags { particle_pusher_flags }
       , m_use_tracking { use_tracking }
-      , m_use_gca { use_gca }
-      , m_cooling { cooling }
+      , m_radiative_drag_flags { radiative_drag_flags }
+      , m_emission_policy_flag { emission_policy_flag }
       , m_npld_r { npld_r }
       , m_npld_i { npld_i } {
       if (use_tracking) {
@@ -144,8 +147,8 @@ namespace ntt {
     }
 
     [[nodiscard]]
-    auto pusher() const -> PrtlPusher {
-      return m_pusher;
+    auto pusher() const -> ParticlePusherFlags {
+      return m_particle_pusher_flags;
     }
 
     [[nodiscard]]
@@ -154,13 +157,13 @@ namespace ntt {
     }
 
     [[nodiscard]]
-    auto use_gca() const -> bool {
-      return m_use_gca;
+    auto radiative_drag_flags() const -> RadiativeDragFlags {
+      return m_radiative_drag_flags;
     }
 
     [[nodiscard]]
-    auto cooling() const -> Cooling {
-      return m_cooling;
+    auto emission_policy_flag() const -> EmissionTypeFlag {
+      return m_emission_policy_flag;
     }
 
     [[nodiscard]]
@@ -172,6 +175,36 @@ namespace ntt {
     auto npld_i() const -> unsigned short {
       return m_npld_i;
     }
+
+    /* reporter -------------------------------------------------------------- */
+    auto Report() const -> std::string {
+      std::string report = "";
+      reporter::AddSubcategory(report,
+                               4,
+                               fmt::format("Species #%d", index()).c_str());
+      reporter::AddParam(report, 6, "Label", "%s", label().c_str());
+      reporter::AddParam(report, 6, "Mass", "%.1f", mass());
+      reporter::AddParam(report, 6, "Charge", "%.1f", charge());
+      reporter::AddParam(report, 6, "Max #", "%d [per domain]", maxnpart());
+      reporter::AddParam(report,
+                         6,
+                         "Pusher",
+                         "%s",
+                         ParticlePusher::to_string(pusher()).c_str());
+      reporter::AddParam(report,
+                         6,
+                         "Radiative drag",
+                         "%s",
+                         RadiativeDrag::to_string(radiative_drag_flags()).c_str());
+      reporter::AddParam(report,
+                         6,
+                         "Emission policy",
+                         "%s",
+                         EmissionType::to_string(emission_policy_flag()).c_str());
+      reporter::AddParam(report, 6, "# of real-value payloads", "%d", npld_r());
+      reporter::AddParam(report, 6, "# of integer-value payloads", "%d", npld_i());
+      return report;
+    }
   };
 } // namespace ntt
 
diff --git a/src/framework/domain/checkpoint.cpp b/src/framework/domain/checkpoint.cpp
index cc4eac43e..693cafc1a 100644
--- a/src/framework/domain/checkpoint.cpp
+++ b/src/framework/domain/checkpoint.cpp
@@ -8,12 +8,13 @@
 #include "utils/log.h"
 
 #include "framework/domain/metadomain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 #include "framework/specialization_registry.h"
 
 namespace ntt {
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::InitCheckpointWriter(adios2::ADIOS*          ptr_adios,
                                               const SimulationParams& params) {
     raise::ErrorIf(ptr_adios == nullptr, "adios == nullptr", HERE);
@@ -64,6 +65,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   auto Metadomain<S, M>::WriteCheckpoint(const SimulationParams& params,
                                          timestep_t              current_step,
                                          timestep_t              finished_step,
@@ -110,6 +112,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::ContinueFromCheckpoint(adios2::ADIOS* ptr_adios,
                                                 const SimulationParams& params) {
     raise::ErrorIf(ptr_adios == nullptr, "adios == nullptr", HERE);
diff --git a/src/framework/domain/communications.cpp b/src/framework/domain/communications.cpp
index ae4ec83d1..66ee4e063 100644
--- a/src/framework/domain/communications.cpp
+++ b/src/framework/domain/communications.cpp
@@ -197,6 +197,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::CommunicateFields(Domain<S, M>& domain, CommTags tags) {
     // const auto comm_fields = (tags & Comm::E) or (tags & Comm::B) or
     //                          (tags & Comm::J) or (tags & Comm::D) or
@@ -417,6 +418,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::SynchronizeFields(Domain<S, M>&        domain,
                                            CommTags             tags,
                                            const range_tuple_t& components) {
@@ -573,6 +575,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::CommunicateParticles(Domain<S, M>& domain) {
 #if defined(MPI_ENABLED)
     logger::Checkpoint("Communicating particles\n", HERE);
@@ -664,6 +667,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::RemoveDeadParticles(Domain<S, M>& domain) {
     for (auto& species : domain.species) {
       species.RemoveDead();
diff --git a/src/framework/domain/domain.h b/src/framework/domain/domain.h
index ca59b74e6..06ffd302d 100644
--- a/src/framework/domain/domain.h
+++ b/src/framework/domain/domain.h
@@ -45,6 +45,9 @@
 #include "arch/directions.h"
 #include "utils/formatting.h"
 #include "utils/numeric.h"
+#include "utils/reporter.h"
+
+#include "metrics/traits.h"
 
 #include "framework/containers/fields.h"
 #include "framework/containers/particles.h"
@@ -58,9 +61,10 @@
 #include <vector>
 
 namespace ntt {
+
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M>
   struct Domain {
-    static_assert(M::is_metric, "template arg for Mesh class has to be a metric");
     static constexpr Dimension D { M::Dim };
 
     Mesh<M>                                 mesh;
@@ -154,10 +158,72 @@ namespace ntt {
     }
 
     /* setters -------------------------------------------------------------- */
-    auto set_neighbor_idx(const dir::direction_t<D>& dir, unsigned int idx) -> void {
+    auto set_neighbor_idx(const dir::direction_t<D>& dir, unsigned int idx)
+      -> void {
       m_neighbor_idx[dir] = idx;
     }
 
+    /* printer overload ----------------------------------------------------- */
+    auto Report() const -> std::string {
+      std::string report = "";
+      reporter::AddSubcategory(report,
+                               4,
+                               fmt::format("Domain #%d", index()).c_str());
+#if defined(MPI_ENABLED)
+      reporter::AddParam(report, 6, "Rank", "%d", mpi_rank());
+#endif
+      reporter::AddParam(report,
+                         6,
+                         "Resolution",
+                         "%s",
+                         fmt::formatVector(mesh.n_active()).c_str());
+      reporter::AddParam(report,
+                         6,
+                         "Extent",
+                         "%s",
+                         fmt::formatVector(mesh.extent()).c_str());
+      reporter::AddSubcategory(report, 6, "Boundary conditions");
+
+      reporter::AddLabel(
+        report,
+        8 + 2 + 2 * M::Dim,
+        fmt::format("%-10s  %-10s  %-10s", "[flds]", "[prtl]", "[neighbor]").c_str());
+      for (auto& direction : dir::Directions<M::Dim>::all) {
+        const auto flds_bc      = mesh.flds_bc_in(direction);
+        const auto prtl_bc      = mesh.prtl_bc_in(direction);
+        bool       has_sync     = false;
+        auto       neighbor_idx = neighbor_idx_in(direction);
+        if (flds_bc == FldsBC::SYNC || prtl_bc == PrtlBC::SYNC) {
+          has_sync = true;
+        }
+        reporter::AddUnlabeledParam(
+          report,
+          8,
+          direction.to_string().c_str(),
+          "%-10s  %-10s  %-10s",
+          flds_bc.to_string(),
+          prtl_bc.to_string(),
+          has_sync ? std::to_string(neighbor_idx).c_str() : ".");
+      }
+      reporter::AddSubcategory(report, 6, "Memory footprint");
+      auto flds_footprint = fields.memory_footprint();
+      auto [flds_size, flds_unit] = reporter::Bytes2HumanReadable(flds_footprint);
+      reporter::AddParam(report, 8, "Fields", "%.2f %s", flds_size, flds_unit.c_str());
+      if (species.size() > 0) {
+        reporter::AddSubcategory(report, 8, "Particles");
+      }
+      for (auto& species : species) {
+        const auto str = fmt::format("Species #%d (%s)",
+                                     species.index(),
+                                     species.label().c_str());
+        auto [size,
+              unit] = reporter::Bytes2HumanReadable(species.memory_footprint());
+        reporter::AddParam(report, 10, str.c_str(), "%.2f %s", size, unit.c_str());
+      }
+      report.pop_back();
+      return report;
+    }
+
   private:
     // index of the domain in the metadomain
     unsigned int                m_index;
@@ -175,8 +241,8 @@ namespace ntt {
   };
 
   template <SimEngine::type S, class M>
-  inline auto operator<<(std::ostream&       os,
-                         const Domain<S, M>& domain) -> std::ostream& {
+  inline auto operator<<(std::ostream& os, const Domain<S, M>& domain)
+    -> std::ostream& {
     os << "Domain #" << domain.index();
 #if defined(MPI_ENABLED)
     os << " [MPI rank: " << domain.mpi_rank() << "]";
diff --git a/src/framework/domain/grid.cpp b/src/framework/domain/grid.cpp
index fa409263b..1e223cbc5 100644
--- a/src/framework/domain/grid.cpp
+++ b/src/framework/domain/grid.cpp
@@ -85,8 +85,8 @@ namespace ntt {
   }
 
   template <Dimension D>
-  auto Grid<D>::rangeCellsOnHost(
-    const box_region_t<D>& region) const -> range_h_t<D> {
+  auto Grid<D>::rangeCellsOnHost(const box_region_t<D>& region) const
+    -> range_h_t<D> {
     tuple_t<ncells_t, D> imin, imax;
     for (auto i { 0u }; i < D; i++) {
       switch (region[i]) {
@@ -162,8 +162,8 @@ namespace ntt {
   }
 
   template <Dimension D>
-  auto Grid<D>::rangeCells(
-    const tuple_t<list_t<int, 2>, D>& ranges) const -> range_t<D> {
+  auto Grid<D>::rangeCells(const tuple_t<list_t<int, 2>, D>& ranges) const
+    -> range_t<D> {
     tuple_t<ncells_t, D> imin, imax;
     for (auto i { 0u }; i < D; i++) {
       raise::ErrorIf((ranges[i][0] < -(int)N_GHOSTS) ||
@@ -177,6 +177,54 @@ namespace ntt {
     return CreateRangePolicy<D>(imin, imax);
   }
 
+  template <>
+  auto Grid<Dim::_1D>::flds_bc() const -> boundaries_t<FldsBC> {
+    return {
+      { flds_bc_in({ -1 }), flds_bc_in({ 1 }) }
+    };
+  }
+
+  template <>
+  auto Grid<Dim::_2D>::flds_bc() const -> boundaries_t<FldsBC> {
+    return {
+      { flds_bc_in({ -1, 0 }), flds_bc_in({ 1, 0 }) },
+      { flds_bc_in({ 0, -1 }), flds_bc_in({ 0, 1 }) }
+    };
+  }
+
+  template <>
+  auto Grid<Dim::_3D>::flds_bc() const -> boundaries_t<FldsBC> {
+    return {
+      { flds_bc_in({ -1, 0, 0 }), flds_bc_in({ 1, 0, 0 }) },
+      { flds_bc_in({ 0, -1, 0 }), flds_bc_in({ 0, 1, 0 }) },
+      { flds_bc_in({ 0, 0, -1 }), flds_bc_in({ 0, 0, 1 }) }
+    };
+  }
+
+  template <>
+  auto Grid<Dim::_1D>::prtl_bc() const -> boundaries_t<PrtlBC> {
+    return {
+      { prtl_bc_in({ -1 }), prtl_bc_in({ 1 }) }
+    };
+  }
+
+  template <>
+  auto Grid<Dim::_2D>::prtl_bc() const -> boundaries_t<PrtlBC> {
+    return {
+      { prtl_bc_in({ -1, 0 }), prtl_bc_in({ 1, 0 }) },
+      { prtl_bc_in({ 0, -1 }), prtl_bc_in({ 0, 1 }) }
+    };
+  }
+
+  template <>
+  auto Grid<Dim::_3D>::prtl_bc() const -> boundaries_t<PrtlBC> {
+    return {
+      { prtl_bc_in({ -1, 0, 0 }), prtl_bc_in({ 1, 0, 0 }) },
+      { prtl_bc_in({ 0, -1, 0 }), prtl_bc_in({ 0, 1, 0 }) },
+      { prtl_bc_in({ 0, 0, -1 }), prtl_bc_in({ 0, 0, 1 }) }
+    };
+  }
+
   template struct Grid<Dim::_1D>;
   template struct Grid<Dim::_2D>;
   template struct Grid<Dim::_3D>;
diff --git a/src/framework/domain/grid.h b/src/framework/domain/grid.h
index 87b21b1f5..6fbe2fae3 100644
--- a/src/framework/domain/grid.h
+++ b/src/framework/domain/grid.h
@@ -62,10 +62,13 @@
 #ifndef FRAMEWORK_DOMAIN_GRID_H
 #define FRAMEWORK_DOMAIN_GRID_H
 
+#include "enums.h"
 #include "global.h"
 
+#include "arch/directions.h"
 #include "arch/kokkos_aliases.h"
 #include "utils/error.h"
+#include "utils/numeric.h"
 
 #include <vector>
 
@@ -73,10 +76,29 @@ namespace ntt {
 
   template <Dimension D>
   struct Grid {
-    Grid(const std::vector<ncells_t>& res) : m_resolution { res } {
+    Grid(const std::vector<ncells_t>& res, const boundaries_t<real_t>& ext)
+      : m_resolution { res }
+      , m_extent { ext } {
       raise::ErrorIf(m_resolution.size() != D, "invalid dimension", HERE);
     }
 
+    Grid(const std::vector<ncells_t>& res,
+         const boundaries_t<real_t>&  ext,
+         const boundaries_t<FldsBC>&  flds_bc,
+         const boundaries_t<PrtlBC>&  prtl_bc)
+      : Grid { res, ext } {
+      for (auto d { 0 }; d < D; ++d) {
+        dir::direction_t<D> dir_plus;
+        dir_plus[d] = +1;
+        dir::direction_t<D> dir_minus;
+        dir_minus[d] = -1;
+        set_flds_bc(dir_plus, flds_bc[d].second);
+        set_flds_bc(dir_minus, flds_bc[d].first);
+        set_prtl_bc(dir_plus, prtl_bc[d].second);
+        set_prtl_bc(dir_minus, prtl_bc[d].first);
+      }
+    }
+
     ~Grid() = default;
 
     /* getters -------------------------------------------------------------- */
@@ -221,8 +243,66 @@ namespace ntt {
      */
     auto rangeCellsOnHost(const box_region_t<D>&) const -> range_h_t<D>;
 
+    /* getters -------------------------------------------------------------- */
+    [[nodiscard]]
+    auto extent(in i) const -> std::pair<real_t, real_t> {
+      switch (i) {
+        case in::x1:
+          return (m_extent.size() > 0) ? m_extent[0]
+                                       : std::pair<real_t, real_t> { ZERO, ZERO };
+        case in::x2:
+          return (m_extent.size() > 1) ? m_extent[1]
+                                       : std::pair<real_t, real_t> { ZERO, ZERO };
+        case in::x3:
+          return (m_extent.size() > 2) ? m_extent[2]
+                                       : std::pair<real_t, real_t> { ZERO, ZERO };
+        default:
+          raise::Error("invalid dimension", HERE);
+          throw;
+      }
+    }
+
+    [[nodiscard]]
+    auto extent() const -> boundaries_t<real_t> {
+      return m_extent;
+    }
+
+    [[nodiscard]]
+    auto flds_bc() const -> boundaries_t<FldsBC>;
+
+    [[nodiscard]]
+    auto prtl_bc() const -> boundaries_t<PrtlBC>;
+
+    [[nodiscard]]
+    auto flds_bc_in(const dir::direction_t<D>& direction) const -> FldsBC {
+      raise::ErrorIf(m_flds_bc.find(direction) == m_flds_bc.end(),
+                     "direction not found",
+                     HERE);
+      return m_flds_bc.at(direction);
+    }
+
+    [[nodiscard]]
+    auto prtl_bc_in(const dir::direction_t<D>& direction) const -> PrtlBC {
+      raise::ErrorIf(m_prtl_bc.find(direction) == m_prtl_bc.end(),
+                     "direction not found",
+                     HERE);
+      return m_prtl_bc.at(direction);
+    }
+
+    /* setters -------------------------------------------------------------- */
+    inline void set_flds_bc(const dir::direction_t<D>& direction, const FldsBC& bc) {
+      m_flds_bc.insert_or_assign(direction, bc);
+    }
+
+    inline void set_prtl_bc(const dir::direction_t<D>& direction, const PrtlBC& bc) {
+      m_prtl_bc.insert_or_assign(direction, bc);
+    }
+
   protected:
     std::vector<ncells_t> m_resolution;
+    boundaries_t<real_t>  m_extent;
+    dir::map_t<D, FldsBC> m_flds_bc;
+    dir::map_t<D, PrtlBC> m_prtl_bc;
   };
 
 } // namespace ntt
diff --git a/src/framework/domain/mesh.h b/src/framework/domain/mesh.h
index 89f6a1b9f..cf7b29aa2 100644
--- a/src/framework/domain/mesh.h
+++ b/src/framework/domain/mesh.h
@@ -16,11 +16,12 @@
 #include "enums.h"
 #include "global.h"
 
-#include "arch/directions.h"
 #include "utils/comparators.h"
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include "framework/domain/grid.h"
 
 #include <map>
@@ -31,39 +32,30 @@
 namespace ntt {
 
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert_i<M>
   struct Mesh : public Grid<M::Dim> {
-    static_assert(M::is_metric, "template arg for Mesh class has to be a metric");
-    static constexpr bool      is_mesh { true };
     static constexpr Dimension D { M::Dim };
+    using base_t = Grid<D>;
+    using base_t::extent;
+    using base_t::m_extent;
+    using base_t::m_flds_bc;
+    using base_t::m_prtl_bc;
 
     M metric;
 
     Mesh(const std::vector<ncells_t>&         res,
          const boundaries_t<real_t>&          ext,
          const std::map<std::string, real_t>& metric_params)
-      : Grid<D> { res }
-      , metric { res, ext, metric_params }
-      , m_extent { ext } {}
+      : Grid<D> { res, ext }
+      , metric { res, ext, metric_params } {}
 
     Mesh(const std::vector<ncells_t>&         res,
          const boundaries_t<real_t>&          ext,
          const std::map<std::string, real_t>& metric_params,
          const boundaries_t<FldsBC>&          flds_bc,
          const boundaries_t<PrtlBC>&          prtl_bc)
-      : Grid<D> { res }
-      , metric { res, ext, metric_params }
-      , m_extent { ext } {
-      for (auto d { 0 }; d < D; ++d) {
-        dir::direction_t<D> dir_plus;
-        dir_plus[d] = +1;
-        dir::direction_t<D> dir_minus;
-        dir_minus[d] = -1;
-        set_flds_bc(dir_plus, flds_bc[d].second);
-        set_flds_bc(dir_minus, flds_bc[d].first);
-        set_prtl_bc(dir_plus, prtl_bc[d].second);
-        set_prtl_bc(dir_minus, prtl_bc[d].first);
-      }
-    }
+      : Grid<D> { res, ext, flds_bc, prtl_bc }
+      , metric { res, ext, metric_params } {}
 
     ~Mesh() = default;
 
@@ -131,9 +123,8 @@ namespace ntt {
      * @note indices are already shifted by N_GHOSTS (i.e. they start at N_GHOSTS not 0)
      */
     [[nodiscard]]
-    auto ExtentToRange(
-      boundaries_t<real_t> box,
-      boundaries_t<bool>   incl_ghosts) const -> boundaries_t<ncells_t> {
+    auto ExtentToRange(boundaries_t<real_t> box, boundaries_t<bool> incl_ghosts) const
+      -> boundaries_t<ncells_t> {
       raise::ErrorIf(box.size() != M::Dim, "Invalid box dimension", HERE);
       raise::ErrorIf(incl_ghosts.size() != M::Dim,
                      "Invalid incl_ghosts dimension",
@@ -194,106 +185,6 @@ namespace ntt {
       }
       return range;
     }
-
-    /* getters -------------------------------------------------------------- */
-    [[nodiscard]]
-    auto extent(in i) const -> std::pair<real_t, real_t> {
-      switch (i) {
-        case in::x1:
-          return (m_extent.size() > 0) ? m_extent[0]
-                                       : std::pair<real_t, real_t> { ZERO, ZERO };
-        case in::x2:
-          return (m_extent.size() > 1) ? m_extent[1]
-                                       : std::pair<real_t, real_t> { ZERO, ZERO };
-        case in::x3:
-          return (m_extent.size() > 2) ? m_extent[2]
-                                       : std::pair<real_t, real_t> { ZERO, ZERO };
-        default:
-          raise::Error("invalid dimension", HERE);
-          throw;
-      }
-    }
-
-    [[nodiscard]]
-    auto extent() const -> boundaries_t<real_t> {
-      return m_extent;
-    }
-
-    [[nodiscard]]
-    auto flds_bc() const -> boundaries_t<FldsBC> {
-      if constexpr (D == Dim::_1D) {
-        return {
-          { flds_bc_in({ -1 }), flds_bc_in({ 1 }) }
-        };
-      } else if constexpr (D == Dim::_2D) {
-        return {
-          { flds_bc_in({ -1, 0 }), flds_bc_in({ 1, 0 }) },
-          { flds_bc_in({ 0, -1 }), flds_bc_in({ 0, 1 }) }
-        };
-      } else if constexpr (D == Dim::_3D) {
-        return {
-          { flds_bc_in({ -1, 0, 0 }), flds_bc_in({ 1, 0, 0 }) },
-          { flds_bc_in({ 0, -1, 0 }), flds_bc_in({ 0, 1, 0 }) },
-          { flds_bc_in({ 0, 0, -1 }), flds_bc_in({ 0, 0, 1 }) }
-        };
-      } else {
-        raise::Error("invalid dimension", HERE);
-        throw;
-      }
-    }
-
-    [[nodiscard]]
-    auto prtl_bc() const -> boundaries_t<PrtlBC> {
-      if constexpr (D == Dim::_1D) {
-        return {
-          { prtl_bc_in({ -1 }), prtl_bc_in({ 1 }) }
-        };
-      } else if constexpr (D == Dim::_2D) {
-        return {
-          { prtl_bc_in({ -1, 0 }), prtl_bc_in({ 1, 0 }) },
-          { prtl_bc_in({ 0, -1 }), prtl_bc_in({ 0, 1 }) }
-        };
-      } else if constexpr (D == Dim::_3D) {
-        return {
-          { prtl_bc_in({ -1, 0, 0 }), prtl_bc_in({ 1, 0, 0 }) },
-          { prtl_bc_in({ 0, -1, 0 }), prtl_bc_in({ 0, 1, 0 }) },
-          { prtl_bc_in({ 0, 0, -1 }), prtl_bc_in({ 0, 0, 1 }) }
-        };
-      } else {
-        raise::Error("invalid dimension", HERE);
-        throw;
-      }
-    }
-
-    [[nodiscard]]
-    auto flds_bc_in(const dir::direction_t<D>& direction) const -> FldsBC {
-      raise::ErrorIf(m_flds_bc.find(direction) == m_flds_bc.end(),
-                     "direction not found",
-                     HERE);
-      return m_flds_bc.at(direction);
-    }
-
-    [[nodiscard]]
-    auto prtl_bc_in(const dir::direction_t<D>& direction) const -> PrtlBC {
-      raise::ErrorIf(m_prtl_bc.find(direction) == m_prtl_bc.end(),
-                     "direction not found",
-                     HERE);
-      return m_prtl_bc.at(direction);
-    }
-
-    /* setters -------------------------------------------------------------- */
-    inline void set_flds_bc(const dir::direction_t<D>& direction, const FldsBC& bc) {
-      m_flds_bc.insert_or_assign(direction, bc);
-    }
-
-    inline void set_prtl_bc(const dir::direction_t<D>& direction, const PrtlBC& bc) {
-      m_prtl_bc.insert_or_assign(direction, bc);
-    }
-
-  private:
-    boundaries_t<real_t>  m_extent;
-    dir::map_t<D, FldsBC> m_flds_bc;
-    dir::map_t<D, PrtlBC> m_prtl_bc;
   };
 } // namespace ntt
 
diff --git a/src/framework/domain/metadomain.cpp b/src/framework/domain/metadomain.cpp
index cbea40843..e31015c24 100644
--- a/src/framework/domain/metadomain.cpp
+++ b/src/framework/domain/metadomain.cpp
@@ -26,6 +26,7 @@
 namespace ntt {
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   Metadomain<S, M>::Metadomain(unsigned int            global_ndomains,
                                const std::vector<int>& global_decomposition,
                                const std::vector<ncells_t>& global_ncells,
@@ -57,6 +58,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::initialValidityCheck() const {
     // ensure everything has the correct shape
     raise::ErrorIf(g_decomposition.size() != (std::size_t)D,
@@ -94,6 +96,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::createEmptyDomains() {
     /* decompose and compute cell & domain offsets ------------------------ */
     auto d_ncells = tools::Decompose(g_ndomains, g_mesh.n_active(), g_decomposition);
@@ -189,6 +192,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::redefineNeighbors() {
     for (unsigned int idx { 0 }; idx < g_ndomains; ++idx) {
       // offset of the subdomain[idx]
@@ -229,6 +233,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::redefineBoundaries() {
     for (unsigned int idx { 0 }; idx < g_ndomains; ++idx) {
       // offset of the subdomain[idx]
@@ -318,6 +323,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::finalValidityCheck() const {
     for (unsigned int idx { 0 }; idx < g_ndomains; ++idx) {
       const auto& current_domain = g_subdomains[idx];
@@ -363,6 +369,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::metricCompatibilityCheck() const {
     const auto epsilon = std::numeric_limits<real_t>::epsilon() *
                          static_cast<real_t>(100.0);
@@ -397,6 +404,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::setFldsBC(const bc_in& dir, const FldsBC& new_bcs) {
     if (dir == bc_in::Mx1) {
       if constexpr (M::Dim == Dim::_1D) {
@@ -465,6 +473,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::setPrtlBC(const bc_in& dir, const PrtlBC& new_bcs) {
     if (dir == bc_in::Mx1) {
       if constexpr (M::Dim == Dim::_1D) {
diff --git a/src/framework/domain/metadomain.h b/src/framework/domain/metadomain.h
index a456879b4..3319cafd4 100644
--- a/src/framework/domain/metadomain.h
+++ b/src/framework/domain/metadomain.h
@@ -20,10 +20,12 @@
 
 #include "arch/kokkos_aliases.h"
 
+#include "metrics/traits.h"
+
 #include "framework/containers/species.h"
 #include "framework/domain/domain.h"
 #include "framework/domain/mesh.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 #include "output/stats.h"
 
 #if defined(MPI_ENABLED)
@@ -35,7 +37,7 @@
   #include "output/writer.h"
 
   #include <adios2.h>
-  #include <adios2/cxx11/KokkosView.h>
+  #include <adios2/cxx/KokkosView.h>
 #endif // OUTPUT_ENABLED
 
 #include <functional>
@@ -46,10 +48,14 @@
 
 namespace ntt {
 
+  template <class M>
+  concept IsCompatibleWithMetadomain = metric::traits::HasD<M> &&
+                                       metric::traits::HasConvert<M> &&
+                                       metric::traits::HasTotVolume<M>;
+
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   struct Metadomain {
-    static_assert(M::is_metric,
-                  "template arg for Metadomain class has to be a metric");
     static constexpr Dimension D { M::Dim };
 
     void initialValidityCheck() const;
diff --git a/src/framework/domain/output.cpp b/src/framework/domain/output.cpp
index 4d625c4d0..1d29c4102 100644
--- a/src/framework/domain/output.cpp
+++ b/src/framework/domain/output.cpp
@@ -9,7 +9,7 @@
 #include "framework/containers/particles.h"
 #include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 #include "framework/specialization_registry.h"
 
 #include "kernels/divergences.hpp"
@@ -31,6 +31,7 @@
 namespace ntt {
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::InitWriter(adios2::ADIOS*          ptr_adios,
                                     const SimulationParams& params) {
     raise::ErrorIf(
@@ -57,8 +58,7 @@ namespace ntt {
 
     g_writer.init(ptr_adios,
                   params.template get<std::string>("output.format"),
-                  params.template get<std::string>("simulation.name"),
-                  params.template get<bool>("output.separate_files"));
+                  params.template get<std::string>("simulation.name"));
     g_writer.defineMeshLayout(glob_shape_with_ghosts,
                               off_ncells_with_ghosts,
                               loc_shape_with_ghosts,
@@ -263,6 +263,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::CommunicateVectorPotential(unsigned short buff_idx) {
     if constexpr (M::Dim == Dim::_2D) {
       auto       local_domain = subdomain_ptr(l_subdomain_indices()[0]);
@@ -316,6 +317,7 @@ namespace ntt {
 #endif
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   auto Metadomain<S, M>::Write(
     const SimulationParams&                  params,
     timestep_t                               current_step,
diff --git a/src/framework/domain/stats.cpp b/src/framework/domain/stats.cpp
index 64690d695..811b35111 100644
--- a/src/framework/domain/stats.cpp
+++ b/src/framework/domain/stats.cpp
@@ -9,7 +9,7 @@
 #include "framework/containers/particles.h"
 #include "framework/domain/domain.h"
 #include "framework/domain/metadomain.h"
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 #include "framework/specialization_registry.h"
 
 #include "kernels/reduced_stats.hpp"
@@ -23,6 +23,7 @@
 namespace ntt {
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   void Metadomain<S, M>::InitStatsWriter(const SimulationParams& params,
                                          bool                    is_resuming) {
     raise::ErrorIf(
@@ -182,6 +183,7 @@ namespace ntt {
   }
 
   template <SimEngine::type S, class M>
+    requires IsCompatibleWithMetadomain<M>
   auto Metadomain<S, M>::WriteStats(
     const SimulationParams& params,
     timestep_t              current_step,
diff --git a/src/framework/parameters.cpp b/src/framework/parameters.cpp
deleted file mode 100644
index 550bb20e0..000000000
--- a/src/framework/parameters.cpp
+++ /dev/null
@@ -1,1120 +0,0 @@
-#include "framework/parameters.h"
-
-#include "defaults.h"
-#include "enums.h"
-#include "global.h"
-
-#include "utils/error.h"
-#include "utils/formatting.h"
-#include "utils/log.h"
-#include "utils/numeric.h"
-#include "utils/toml.h"
-
-#include "metrics/kerr_schild.h"
-#include "metrics/kerr_schild_0.h"
-#include "metrics/minkowski.h"
-#include "metrics/qkerr_schild.h"
-#include "metrics/qspherical.h"
-#include "metrics/spherical.h"
-
-#include "framework/containers/species.h"
-
-#if defined(MPI_ENABLED)
-  #include <mpi.h>
-#endif
-
-#include <fstream>
-#include <iostream>
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace ntt {
-
-  template <typename M>
-  auto get_dx0_V0(
-    const std::vector<ncells_t>&         resolution,
-    const boundaries_t<real_t>&          extent,
-    const std::map<std::string, real_t>& params) -> std::pair<real_t, real_t> {
-    const auto      metric = M(resolution, extent, params);
-    const auto      dx0    = metric.dxMin();
-    coord_t<M::Dim> x_corner { ZERO };
-    for (auto d { 0u }; d < M::Dim; ++d) {
-      x_corner[d] = HALF;
-    }
-    const auto V0 = metric.sqrt_det_h(x_corner);
-    return { dx0, V0 };
-  }
-
-  /*
-   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-   * Parameters that must not be changed during the checkpoint restart
-   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-   */
-  void SimulationParams::setImmutableParams(const toml::value& toml_data) {
-    /* [simulation] --------------------------------------------------------- */
-    const auto engine_enum = SimEngine::pick(
-      fmt::toLower(toml::find<std::string>(toml_data, "simulation", "engine")).c_str());
-    set("simulation.engine", engine_enum);
-
-    int default_ndomains = 1;
-#if defined(MPI_ENABLED)
-    raise::ErrorIf(MPI_Comm_size(MPI_COMM_WORLD, &default_ndomains) != MPI_SUCCESS,
-                   "MPI_Comm_size failed",
-                   HERE);
-#endif
-    const auto ndoms = toml::find_or(toml_data,
-                                     "simulation",
-                                     "domain",
-                                     "number",
-                                     default_ndomains);
-    set("simulation.domain.number", (unsigned int)ndoms);
-
-    auto decomposition = toml::find_or<std::vector<int>>(
-      toml_data,
-      "simulation",
-      "domain",
-      "decomposition",
-      std::vector<int> { -1, -1, -1 });
-    promiseToDefine("simulation.domain.decomposition");
-
-    /* [grid] --------------------------------------------------------------- */
-    const auto res = toml::find<std::vector<ncells_t>>(toml_data,
-                                                       "grid",
-                                                       "resolution");
-    raise::ErrorIf(res.size() < 1 || res.size() > 3,
-                   "invalid `grid.resolution`",
-                   HERE);
-    set("grid.resolution", res);
-    const auto dim = static_cast<Dimension>(res.size());
-    set("grid.dim", dim);
-
-    if (decomposition.size() > dim) {
-      decomposition.erase(decomposition.begin() + (std::size_t)(dim),
-                          decomposition.end());
-    }
-    raise::ErrorIf(decomposition.size() != dim,
-                   "invalid `simulation.domain.decomposition`",
-                   HERE);
-    set("simulation.domain.decomposition", decomposition);
-
-    auto extent = toml::find<std::vector<std::vector<real_t>>>(toml_data,
-                                                               "grid",
-                                                               "extent");
-    raise::ErrorIf(extent.size() < 1 || extent.size() > 3,
-                   "invalid `grid.extent`",
-                   HERE);
-    promiseToDefine("grid.extent");
-
-    /* [grid.metric] -------------------------------------------------------- */
-    const auto metric_enum = Metric::pick(
-      fmt::toLower(toml::find<std::string>(toml_data, "grid", "metric", "metric"))
-        .c_str());
-    promiseToDefine("grid.metric.metric");
-    std::string coord;
-    if (metric_enum == Metric::Minkowski) {
-      raise::ErrorIf(engine_enum != SimEngine::SRPIC,
-                     "minkowski metric is only supported for SRPIC",
-                     HERE);
-      coord = "cart";
-    } else if (metric_enum == Metric::QKerr_Schild or
-               metric_enum == Metric::QSpherical) {
-      // quasi-spherical geometry
-      raise::ErrorIf(dim == Dim::_1D,
-                     "not enough dimensions for qspherical geometry",
-                     HERE);
-      raise::ErrorIf(dim == Dim::_3D,
-                     "3D not implemented for qspherical geometry",
-                     HERE);
-      coord = "qsph";
-      set("grid.metric.qsph_r0",
-          toml::find_or(toml_data, "grid", "metric", "qsph_r0", defaults::qsph::r0));
-      set("grid.metric.qsph_h",
-          toml::find_or(toml_data, "grid", "metric", "qsph_h", defaults::qsph::h));
-    } else {
-      // spherical geometry
-      raise::ErrorIf(dim == Dim::_1D,
-                     "not enough dimensions for spherical geometry",
-                     HERE);
-      raise::ErrorIf(dim == Dim::_3D,
-                     "3D not implemented for spherical geometry",
-                     HERE);
-      coord = "sph";
-    }
-    if ((engine_enum == SimEngine::GRPIC) &&
-        (metric_enum != Metric::Kerr_Schild_0)) {
-      const auto ks_a = toml::find_or(toml_data,
-                                      "grid",
-                                      "metric",
-                                      "ks_a",
-                                      defaults::ks::a);
-      set("grid.metric.ks_a", ks_a);
-      set("grid.metric.ks_rh", ONE + math::sqrt(ONE - SQR(ks_a)));
-    }
-    const auto coord_enum = Coord::pick(coord.c_str());
-    set("grid.metric.coord", coord_enum);
-
-    /* [scales] ------------------------------------------------------------- */
-    const auto larmor0 = toml::find<real_t>(toml_data, "scales", "larmor0");
-    const auto skindepth0 = toml::find<real_t>(toml_data, "scales", "skindepth0");
-    raise::ErrorIf(larmor0 <= ZERO || skindepth0 <= ZERO,
-                   "larmor0 and skindepth0 must be positive",
-                   HERE);
-    set("scales.larmor0", larmor0);
-    set("scales.skindepth0", skindepth0);
-    promiseToDefine("scales.dx0");
-    promiseToDefine("scales.V0");
-    promiseToDefine("scales.n0");
-    promiseToDefine("scales.q0");
-    set("scales.sigma0", SQR(skindepth0 / larmor0));
-    set("scales.B0", ONE / larmor0);
-    set("scales.omegaB0", ONE / larmor0);
-
-    /* [particles] ---------------------------------------------------------- */
-    const auto ppc0 = toml::find<real_t>(toml_data, "particles", "ppc0");
-    set("particles.ppc0", ppc0);
-    raise::ErrorIf(ppc0 <= 0.0, "ppc0 must be positive", HERE);
-    set("particles.use_weights",
-        toml::find_or(toml_data, "particles", "use_weights", false));
-
-    /* [particles.species] -------------------------------------------------- */
-    std::vector<ParticleSpecies> species;
-    const auto species_tab = toml::find_or<toml::array>(toml_data,
-                                                        "particles",
-                                                        "species",
-                                                        toml::array {});
-    set("particles.nspec", species_tab.size());
-
-    spidx_t idx = 1;
-    for (const auto& sp : species_tab) {
-      const auto label  = toml::find_or<std::string>(sp,
-                                                    "label",
-                                                    "s" + std::to_string(idx));
-      const auto mass   = toml::find<float>(sp, "mass");
-      const auto charge = toml::find<float>(sp, "charge");
-      raise::ErrorIf((charge != 0.0f) && (mass == 0.0f),
-                     "mass of the charged species must be non-zero",
-                     HERE);
-      const auto is_massless   = (mass == 0.0f) && (charge == 0.0f);
-      const auto def_pusher    = (is_massless ? defaults::ph_pusher
-                                              : defaults::em_pusher);
-      const auto maxnpart_real = toml::find<double>(sp, "maxnpart");
-      const auto maxnpart      = static_cast<npart_t>(maxnpart_real);
-      auto       pusher = toml::find_or(sp, "pusher", std::string(def_pusher));
-      const auto npayloads_real = toml::find_or(sp,
-                                                "n_payloads_real",
-                                                static_cast<unsigned short>(0));
-      const auto use_tracking   = toml::find_or(sp, "tracking", false);
-      auto       npayloads_int  = toml::find_or(sp,
-                                         "n_payloads_int",
-                                         static_cast<unsigned short>(0));
-      if (use_tracking) {
-#if !defined(MPI_ENABLED)
-        npayloads_int += 1;
-#else
-        npayloads_int += 2;
-#endif
-      }
-      const auto cooling = toml::find_or(sp, "cooling", std::string("None"));
-      raise::ErrorIf((fmt::toLower(cooling) != "none") && is_massless,
-                     "cooling is only applicable to massive particles",
-                     HERE);
-      raise::ErrorIf((fmt::toLower(pusher) == "photon") && !is_massless,
-                     "photon pusher is only applicable to massless particles",
-                     HERE);
-      bool use_gca = false;
-      if (pusher.find(',') != std::string::npos) {
-        raise::ErrorIf(fmt::toLower(pusher.substr(pusher.find(',') + 1,
-                                                  pusher.size())) != "gca",
-                       "invalid pusher syntax",
-                       HERE);
-        use_gca = true;
-        pusher  = pusher.substr(0, pusher.find(','));
-      }
-      const auto pusher_enum  = PrtlPusher::pick(pusher.c_str());
-      const auto cooling_enum = Cooling::pick(cooling.c_str());
-      if (use_gca) {
-        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
-                       "GCA pushers are only supported for SRPIC",
-                       HERE);
-        promiseToDefine("algorithms.gca.e_ovr_b_max");
-        promiseToDefine("algorithms.gca.larmor_max");
-      }
-      if (cooling_enum == Cooling::SYNCHROTRON) {
-        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
-                       "Synchrotron cooling is only supported for SRPIC",
-                       HERE);
-        promiseToDefine("algorithms.synchrotron.gamma_rad");
-      }
-
-      if (cooling_enum == Cooling::COMPTON) {
-        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
-                       "Inverse Compton cooling is only supported for SRPIC",
-                       HERE);
-        promiseToDefine("algorithms.compton.gamma_rad");
-      }
-
-      species.emplace_back(ParticleSpecies(idx,
-                                           label,
-                                           mass,
-                                           charge,
-                                           maxnpart,
-                                           pusher_enum,
-                                           use_tracking,
-                                           use_gca,
-                                           cooling_enum,
-                                           npayloads_real,
-                                           npayloads_int));
-      idx += 1;
-    }
-    set("particles.species", species);
-
-    /* inferred variables --------------------------------------------------- */
-    // extent
-    if (extent.size() > dim) {
-      extent.erase(extent.begin() + (std::size_t)(dim), extent.end());
-    }
-    raise::ErrorIf(extent[0].size() != 2, "invalid `grid.extent[0]`", HERE);
-    if (coord_enum != Coord::Cart) {
-      raise::ErrorIf(extent.size() > 1,
-                     "invalid `grid.extent` for non-cartesian geometry",
-                     HERE);
-      extent.push_back({ ZERO, constant::PI });
-      if (dim == Dim::_3D) {
-        extent.push_back({ ZERO, TWO * constant::PI });
-      }
-    }
-    raise::ErrorIf(extent.size() != dim, "invalid inferred `grid.extent`", HERE);
-    boundaries_t<real_t> extent_pairwise;
-    for (auto d { 0u }; d < (dim_t)dim; ++d) {
-      raise::ErrorIf(extent[d].size() != 2,
-                     fmt::format("invalid inferred `grid.extent[%d]`", d),
-                     HERE);
-      extent_pairwise.push_back({ extent[d][0], extent[d][1] });
-    }
-    set("grid.extent", extent_pairwise);
-
-    // metric, dx0, V0, n0, q0
-    {
-      boundaries_t<real_t> ext;
-      for (const auto& e : extent) {
-        ext.push_back({ e[0], e[1] });
-      }
-      std::map<std::string, real_t> params;
-      if (coord_enum == Coord::Qsph) {
-        params["r0"] = get<real_t>("grid.metric.qsph_r0");
-        params["h"]  = get<real_t>("grid.metric.qsph_h");
-      }
-      if ((engine_enum == SimEngine::GRPIC) &&
-          (metric_enum != Metric::Kerr_Schild_0)) {
-        params["a"] = get<real_t>("grid.metric.ks_a");
-      }
-      set("grid.metric.params", params);
-
-      std::pair<real_t, real_t> dx0_V0;
-      if (metric_enum == Metric::Minkowski) {
-        if (dim == Dim::_1D) {
-          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_1D>>(res, ext, params);
-        } else if (dim == Dim::_2D) {
-          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_2D>>(res, ext, params);
-        } else {
-          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_3D>>(res, ext, params);
-        }
-      } else if (metric_enum == Metric::Spherical) {
-        dx0_V0 = get_dx0_V0<metric::Spherical<Dim::_2D>>(res, ext, params);
-      } else if (metric_enum == Metric::QSpherical) {
-        dx0_V0 = get_dx0_V0<metric::QSpherical<Dim::_2D>>(res, ext, params);
-      } else if (metric_enum == Metric::Kerr_Schild) {
-        dx0_V0 = get_dx0_V0<metric::KerrSchild<Dim::_2D>>(res, ext, params);
-      } else if (metric_enum == Metric::Kerr_Schild_0) {
-        dx0_V0 = get_dx0_V0<metric::KerrSchild0<Dim::_2D>>(res, ext, params);
-      } else if (metric_enum == Metric::QKerr_Schild) {
-        dx0_V0 = get_dx0_V0<metric::QKerrSchild<Dim::_2D>>(res, ext, params);
-      }
-      auto [dx0, V0] = dx0_V0;
-      set("scales.dx0", dx0);
-      set("scales.V0", V0);
-      set("scales.n0", ppc0 / V0);
-      set("scales.q0", V0 / (ppc0 * SQR(skindepth0)));
-
-      set("grid.metric.metric", metric_enum);
-    }
-  }
-
-  /*
-   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-   * Parameters that may be changed during the checkpoint restart
-   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-   */
-  void SimulationParams::setMutableParams(const toml::value& toml_data) {
-    const auto engine_enum     = get<SimEngine>("simulation.engine");
-    const auto coord_enum      = get<Coord>("grid.metric.coord");
-    const auto dim             = get<Dimension>("grid.dim");
-    const auto extent_pairwise = get<boundaries_t<real_t>>("grid.extent");
-
-    /* [simulation] --------------------------------------------------------- */
-    set("simulation.name",
-        toml::find<std::string>(toml_data, "simulation", "name"));
-    set("simulation.runtime",
-        toml::find<simtime_t>(toml_data, "simulation", "runtime"));
-
-    /* [grid.boundaraies] --------------------------------------------------- */
-    auto flds_bc = toml::find<std::vector<std::vector<std::string>>>(
-      toml_data,
-      "grid",
-      "boundaries",
-      "fields");
-    {
-      raise::ErrorIf(flds_bc.size() < 1 || flds_bc.size() > 3,
-                     "invalid `grid.boundaries.fields`",
-                     HERE);
-      promiseToDefine("grid.boundaries.fields");
-      auto atm_defined = false;
-      for (const auto& bcs : flds_bc) {
-        for (const auto& bc : bcs) {
-          if (fmt::toLower(bc) == "match") {
-            promiseToDefine("grid.boundaries.match.ds");
-          }
-          if (fmt::toLower(bc) == "atmosphere") {
-            raise::ErrorIf(atm_defined,
-                           "ATMOSPHERE is only allowed in one direction",
-                           HERE);
-            atm_defined = true;
-            promiseToDefine("grid.boundaries.atmosphere.temperature");
-            promiseToDefine("grid.boundaries.atmosphere.density");
-            promiseToDefine("grid.boundaries.atmosphere.height");
-            promiseToDefine("grid.boundaries.atmosphere.ds");
-            promiseToDefine("grid.boundaries.atmosphere.species");
-            promiseToDefine("grid.boundaries.atmosphere.g");
-          }
-        }
-      }
-    }
-
-    auto prtl_bc = toml::find<std::vector<std::vector<std::string>>>(
-      toml_data,
-      "grid",
-      "boundaries",
-      "particles");
-    {
-      raise::ErrorIf(prtl_bc.size() < 1 || prtl_bc.size() > 3,
-                     "invalid `grid.boundaries.particles`",
-                     HERE);
-      promiseToDefine("grid.boundaries.particles");
-      auto atm_defined = false;
-      for (const auto& bcs : prtl_bc) {
-        for (const auto& bc : bcs) {
-          if (fmt::toLower(bc) == "absorb") {
-            promiseToDefine("grid.boundaries.absorb.ds");
-          }
-          if (fmt::toLower(bc) == "atmosphere") {
-            raise::ErrorIf(atm_defined,
-                           "ATMOSPHERE is only allowed in one direction",
-                           HERE);
-            atm_defined = true;
-            promiseToDefine("grid.boundaries.atmosphere.temperature");
-            promiseToDefine("grid.boundaries.atmosphere.density");
-            promiseToDefine("grid.boundaries.atmosphere.height");
-            promiseToDefine("grid.boundaries.atmosphere.ds");
-            promiseToDefine("grid.boundaries.atmosphere.species");
-            promiseToDefine("grid.boundaries.atmosphere.g");
-          }
-        }
-      }
-    }
-
-    /* [algorithms] --------------------------------------------------------- */
-    set("algorithms.current_filters",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "current_filters",
-                      defaults::current_filters));
-
-    /* [algorithms.deposit] ------------------------------------------------- */
-    set("algorithms.deposit.enable",
-        toml::find_or(toml_data, "algorithms", "deposit", "enable", true));
-    set("algorithms.deposit.order",
-        toml::find_or(toml_data, "algorithms", "deposit", "order", 1));
-
-    /* [algorithms.fieldsolver] --------------------------------------------- */
-    set("algorithms.fieldsolver.enable",
-        toml::find_or(toml_data, "algorithms", "fieldsolver", "enable", true));
-
-    set("algorithms.fieldsolver.delta_x",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "delta_x",
-                      defaults::fieldsolver::delta_x));
-    set("algorithms.fieldsolver.delta_y",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "delta_y",
-                      defaults::fieldsolver::delta_y));
-    set("algorithms.fieldsolver.delta_z",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "delta_z",
-                      defaults::fieldsolver::delta_z));
-    set("algorithms.fieldsolver.beta_xy",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_xy",
-                      defaults::fieldsolver::beta_xy));
-    set("algorithms.fieldsolver.beta_yx",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_yx",
-                      defaults::fieldsolver::beta_yx));
-    set("algorithms.fieldsolver.beta_xz",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_xz",
-                      defaults::fieldsolver::beta_xz));
-    set("algorithms.fieldsolver.beta_zx",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_zx",
-                      defaults::fieldsolver::beta_zx));
-    set("algorithms.fieldsolver.beta_yz",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_yz",
-                      defaults::fieldsolver::beta_yz));
-    set("algorithms.fieldsolver.beta_zy",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "fieldsolver",
-                      "beta_zy",
-                      defaults::fieldsolver::beta_zy));
-    /* [algorithms.timestep] ------------------------------------------------ */
-    set("algorithms.timestep.CFL",
-        toml::find_or(toml_data, "algorithms", "timestep", "CFL", defaults::cfl));
-    set("algorithms.timestep.dt",
-        get<real_t>("algorithms.timestep.CFL") * get<real_t>("scales.dx0"));
-    set("algorithms.timestep.correction",
-        toml::find_or(toml_data,
-                      "algorithms",
-                      "timestep",
-                      "correction",
-                      defaults::correction));
-
-    /* [algorithms.gr] ------------------------------------------------------ */
-    if (engine_enum == SimEngine::GRPIC) {
-      set("algorithms.gr.pusher_eps",
-          toml::find_or(toml_data,
-                        "algorithms",
-                        "gr",
-                        "pusher_eps",
-                        defaults::gr::pusher_eps));
-      set("algorithms.gr.pusher_niter",
-          toml::find_or(toml_data,
-                        "algorithms",
-                        "gr",
-                        "pusher_niter",
-                        defaults::gr::pusher_niter));
-    }
-    /* [particles] ---------------------------------------------------------- */
-    set("particles.clear_interval",
-        toml::find_or(toml_data, "particles", "clear_interval", defaults::clear_interval));
-    const auto species_tab               = toml::find_or<toml::array>(toml_data,
-                                                        "particles",
-                                                        "species",
-                                                        toml::array {});
-    std::vector<ParticleSpecies> species = get<std::vector<ParticleSpecies>>(
-      "particles.species");
-    raise::ErrorIf(species_tab.size() != species.size(),
-                   "number of species changed after restart",
-                   HERE);
-
-    std::vector<ParticleSpecies> new_species;
-
-    spidx_t idxM1 = 0;
-    for (const auto& sp : species_tab) {
-      const auto maxnpart_real    = toml::find<double>(sp, "maxnpart");
-      const auto maxnpart         = static_cast<npart_t>(maxnpart_real);
-      const auto particle_species = species[idxM1];
-      new_species.emplace_back(particle_species.index(),
-                               particle_species.label(),
-                               particle_species.mass(),
-                               particle_species.charge(),
-                               maxnpart,
-                               particle_species.pusher(),
-                               particle_species.use_tracking(),
-                               particle_species.use_gca(),
-                               particle_species.cooling(),
-                               particle_species.npld_r(),
-                               particle_species.npld_i());
-      idxM1++;
-    }
-    set("particles.species", new_species);
-
-    /* [output] ------------------------------------------------------------- */
-    // fields
-    set("output.format",
-        toml::find_or(toml_data, "output", "format", defaults::output::format));
-    set("output.interval",
-        toml::find_or(toml_data, "output", "interval", defaults::output::interval));
-    set("output.interval_time",
-        toml::find_or<simtime_t>(toml_data, "output", "interval_time", -1.0));
-    set("output.separate_files",
-        toml::find_or<bool>(toml_data, "output", "separate_files", true));
-
-    promiseToDefine("output.fields.enable");
-    promiseToDefine("output.fields.interval");
-    promiseToDefine("output.fields.interval_time");
-    promiseToDefine("output.particles.enable");
-    promiseToDefine("output.particles.interval");
-    promiseToDefine("output.particles.interval_time");
-    promiseToDefine("output.spectra.enable");
-    promiseToDefine("output.spectra.interval");
-    promiseToDefine("output.spectra.interval_time");
-    promiseToDefine("output.stats.enable");
-    promiseToDefine("output.stats.interval");
-    promiseToDefine("output.stats.interval_time");
-
-    const auto flds_out        = toml::find_or(toml_data,
-                                        "output",
-                                        "fields",
-                                        "quantities",
-                                        std::vector<std::string> {});
-    const auto custom_flds_out = toml::find_or(toml_data,
-                                               "output",
-                                               "fields",
-                                               "custom",
-                                               std::vector<std::string> {});
-    if (flds_out.size() == 0) {
-      raise::Warning("No fields output specified", HERE);
-    }
-    set("output.fields.quantities", flds_out);
-    set("output.fields.custom", custom_flds_out);
-    set("output.fields.mom_smooth",
-        toml::find_or(toml_data,
-                      "output",
-                      "fields",
-                      "mom_smooth",
-                      defaults::output::mom_smooth));
-    std::vector<unsigned int> field_dwn;
-    try {
-      auto field_dwn_ = toml::find<std::vector<unsigned int>>(toml_data,
-                                                              "output",
-                                                              "fields",
-                                                              "downsampling");
-      for (auto i = 0u; i < field_dwn_.size(); ++i) {
-        field_dwn.push_back(field_dwn_[i]);
-      }
-    } catch (...) {
-      try {
-        auto field_dwn_ = toml::find<unsigned int>(toml_data,
-                                                   "output",
-                                                   "fields",
-                                                   "downsampling");
-        for (auto i = 0u; i < dim; ++i) {
-          field_dwn.push_back(field_dwn_);
-        }
-      } catch (...) {
-        for (auto i = 0u; i < dim; ++i) {
-          field_dwn.push_back(1u);
-        }
-      }
-    }
-    raise::ErrorIf(field_dwn.size() > 3, "invalid `output.fields.downsampling`", HERE);
-    if (field_dwn.size() > dim) {
-      field_dwn.erase(field_dwn.begin() + (std::size_t)(dim), field_dwn.end());
-    }
-    for (const auto& dwn : field_dwn) {
-      raise::ErrorIf(dwn == 0, "downsampling factor must be nonzero", HERE);
-    }
-    set("output.fields.downsampling", field_dwn);
-
-    // particles
-    auto       all_specs = std::vector<spidx_t> {};
-    const auto nspec     = get<std::size_t>("particles.nspec");
-    for (auto i = 0u; i < nspec; ++i) {
-      all_specs.push_back(static_cast<spidx_t>(i + 1));
-    }
-    const auto prtl_out = toml::find_or(toml_data,
-                                        "output",
-                                        "particles",
-                                        "species",
-                                        all_specs);
-    set("output.particles.species", prtl_out);
-    set("output.particles.stride",
-        toml::find_or(toml_data,
-                      "output",
-                      "particles",
-                      "stride",
-                      defaults::output::prtl_stride));
-
-    // spectra
-    set("output.spectra.e_min",
-        toml::find_or(toml_data, "output", "spectra", "e_min", defaults::output::spec_emin));
-    set("output.spectra.e_max",
-        toml::find_or(toml_data, "output", "spectra", "e_max", defaults::output::spec_emax));
-    set("output.spectra.log_bins",
-        toml::find_or(toml_data,
-                      "output",
-                      "spectra",
-                      "log_bins",
-                      defaults::output::spec_log));
-    set("output.spectra.n_bins",
-        toml::find_or(toml_data,
-                      "output",
-                      "spectra",
-                      "n_bins",
-                      defaults::output::spec_nbins));
-
-    // stats
-    set("output.stats.quantities",
-        toml::find_or(toml_data,
-                      "output",
-                      "stats",
-                      "quantities",
-                      defaults::output::stats_quantities));
-    set("output.stats.custom",
-        toml::find_or(toml_data,
-                      "output",
-                      "stats",
-                      "custom",
-                      std::vector<std::string> {}));
-
-    // intervals
-    for (const auto& type : { "fields", "particles", "spectra", "stats" }) {
-      const auto q_int      = toml::find_or<timestep_t>(toml_data,
-                                                   "output",
-                                                   std::string(type),
-                                                   "interval",
-                                                   0);
-      const auto q_int_time = toml::find_or<simtime_t>(toml_data,
-                                                       "output",
-                                                       std::string(type),
-                                                       "interval_time",
-                                                       -1.0);
-      set("output." + std::string(type) + ".enable",
-          toml::find_or(toml_data, "output", std::string(type), "enable", true));
-      if ((q_int == 0) and (q_int_time == -1.0)) {
-        set("output." + std::string(type) + ".interval",
-            get<timestep_t>("output.interval"));
-        set("output." + std::string(type) + ".interval_time",
-            get<simtime_t>("output.interval_time"));
-      } else {
-        set("output." + std::string(type) + ".interval", q_int);
-        set("output." + std::string(type) + ".interval_time", q_int_time);
-      }
-    }
-
-    /* [output.debug] ------------------------------------------------------- */
-    set("output.debug.as_is",
-        toml::find_or(toml_data, "output", "debug", "as_is", false));
-    const auto output_ghosts = toml::find_or(toml_data,
-                                             "output",
-                                             "debug",
-                                             "ghosts",
-                                             false);
-    set("output.debug.ghosts", output_ghosts);
-    if (output_ghosts) {
-      for (const auto& dwn : field_dwn) {
-        raise::ErrorIf(
-          dwn != 1,
-          "full resolution required when outputting with ghost cells",
-          HERE);
-      }
-    }
-
-    /* [checkpoint] --------------------------------------------------------- */
-    set("checkpoint.interval",
-        toml::find_or(toml_data,
-                      "checkpoint",
-                      "interval",
-                      defaults::checkpoint::interval));
-    set("checkpoint.interval_time",
-        toml::find_or<simtime_t>(toml_data, "checkpoint", "interval_time", -1.0));
-    set("checkpoint.keep",
-        toml::find_or(toml_data, "checkpoint", "keep", defaults::checkpoint::keep));
-    auto walltime_str = toml::find_or(toml_data,
-                                      "checkpoint",
-                                      "walltime",
-                                      defaults::checkpoint::walltime);
-    if (walltime_str.empty()) {
-      walltime_str = defaults::checkpoint::walltime;
-    }
-    set("checkpoint.walltime", walltime_str);
-
-    const auto checkpoint_write_path = toml::find_or(
-      toml_data,
-      "checkpoint",
-      "write_path",
-      fmt::format(defaults::checkpoint::write_path.c_str(),
-                  get<std::string>("simulation.name").c_str()));
-    set("checkpoint.write_path", checkpoint_write_path);
-    set("checkpoint.read_path",
-        toml::find_or(toml_data, "checkpoint", "read_path", checkpoint_write_path));
-
-    /* [diagnostics] -------------------------------------------------------- */
-    set("diagnostics.interval",
-        toml::find_or(toml_data, "diagnostics", "interval", defaults::diag::interval));
-    set("diagnostics.blocking_timers",
-        toml::find_or(toml_data, "diagnostics", "blocking_timers", false));
-    set("diagnostics.colored_stdout",
-        toml::find_or(toml_data, "diagnostics", "colored_stdout", false));
-    set("diagnostics.log_level",
-        toml::find_or(toml_data, "diagnostics", "log_level", defaults::diag::log_level));
-
-    /* inferred variables --------------------------------------------------- */
-    // fields/particle boundaries
-    std::vector<std::vector<FldsBC>> flds_bc_enum;
-    std::vector<std::vector<PrtlBC>> prtl_bc_enum;
-    if (coord_enum == Coord::Cart) {
-      raise::ErrorIf(flds_bc.size() != (std::size_t)dim,
-                     "invalid `grid.boundaries.fields`",
-                     HERE);
-      raise::ErrorIf(prtl_bc.size() != (std::size_t)dim,
-                     "invalid `grid.boundaries.particles`",
-                     HERE);
-      for (auto d { 0u }; d < (dim_t)dim; ++d) {
-        flds_bc_enum.push_back({});
-        prtl_bc_enum.push_back({});
-        const auto fbc = flds_bc[d];
-        const auto pbc = prtl_bc[d];
-        raise::ErrorIf(fbc.size() < 1 || fbc.size() > 2,
-                       "invalid `grid.boundaries.fields`",
-                       HERE);
-        raise::ErrorIf(pbc.size() < 1 || pbc.size() > 2,
-                       "invalid `grid.boundaries.particles`",
-                       HERE);
-        auto fbc_enum = FldsBC::pick(fmt::toLower(fbc[0]).c_str());
-        auto pbc_enum = PrtlBC::pick(fmt::toLower(pbc[0]).c_str());
-        if (fbc.size() == 1) {
-          raise::ErrorIf(fbc_enum != FldsBC::PERIODIC,
-                         "invalid `grid.boundaries.fields`",
-                         HERE);
-          flds_bc_enum.back().push_back(FldsBC(FldsBC::PERIODIC));
-          flds_bc_enum.back().push_back(FldsBC(FldsBC::PERIODIC));
-        } else {
-          raise::ErrorIf(fbc_enum == FldsBC::PERIODIC,
-                         "invalid `grid.boundaries.fields`",
-                         HERE);
-          flds_bc_enum.back().push_back(fbc_enum);
-          auto fbc_enum = FldsBC::pick(fmt::toLower(fbc[1]).c_str());
-          raise::ErrorIf(fbc_enum == FldsBC::PERIODIC,
-                         "invalid `grid.boundaries.fields`",
-                         HERE);
-          flds_bc_enum.back().push_back(fbc_enum);
-        }
-        if (pbc.size() == 1) {
-          raise::ErrorIf(pbc_enum != PrtlBC::PERIODIC,
-                         "invalid `grid.boundaries.particles`",
-                         HERE);
-          prtl_bc_enum.back().push_back(PrtlBC(PrtlBC::PERIODIC));
-          prtl_bc_enum.back().push_back(PrtlBC(PrtlBC::PERIODIC));
-        } else {
-          raise::ErrorIf(pbc_enum == PrtlBC::PERIODIC,
-                         "invalid `grid.boundaries.particles`",
-                         HERE);
-          prtl_bc_enum.back().push_back(pbc_enum);
-          auto pbc_enum = PrtlBC::pick(fmt::toLower(pbc[1]).c_str());
-          raise::ErrorIf(pbc_enum == PrtlBC::PERIODIC,
-                         "invalid `grid.boundaries.particles`",
-                         HERE);
-          prtl_bc_enum.back().push_back(pbc_enum);
-        }
-      }
-    } else {
-      raise::ErrorIf(flds_bc.size() > 1, "invalid `grid.boundaries.fields`", HERE);
-      raise::ErrorIf(prtl_bc.size() > 1, "invalid `grid.boundaries.particles`", HERE);
-      if (engine_enum == SimEngine::SRPIC) {
-        raise::ErrorIf(flds_bc[0].size() != 2,
-                       "invalid `grid.boundaries.fields`",
-                       HERE);
-        flds_bc_enum.push_back(
-          { FldsBC::pick(fmt::toLower(flds_bc[0][0]).c_str()),
-            FldsBC::pick(fmt::toLower(flds_bc[0][1]).c_str()) });
-        flds_bc_enum.push_back({ FldsBC::AXIS, FldsBC::AXIS });
-        if (dim == Dim::_3D) {
-          flds_bc_enum.push_back({ FldsBC::PERIODIC, FldsBC::PERIODIC });
-        }
-        raise::ErrorIf(prtl_bc[0].size() != 2,
-                       "invalid `grid.boundaries.particles`",
-                       HERE);
-        prtl_bc_enum.push_back(
-          { PrtlBC::pick(fmt::toLower(prtl_bc[0][0]).c_str()),
-            PrtlBC::pick(fmt::toLower(prtl_bc[0][1]).c_str()) });
-        prtl_bc_enum.push_back({ PrtlBC::AXIS, PrtlBC::AXIS });
-        if (dim == Dim::_3D) {
-          prtl_bc_enum.push_back({ PrtlBC::PERIODIC, PrtlBC::PERIODIC });
-        }
-      } else {
-        raise::ErrorIf(flds_bc[0].size() != 1,
-                       "invalid `grid.boundaries.fields`",
-                       HERE);
-        raise::ErrorIf(prtl_bc[0].size() != 1,
-                       "invalid `grid.boundaries.particles`",
-                       HERE);
-        flds_bc_enum.push_back(
-          { FldsBC::HORIZON, FldsBC::pick(fmt::toLower(flds_bc[0][0]).c_str()) });
-        flds_bc_enum.push_back({ FldsBC::AXIS, FldsBC::AXIS });
-        if (dim == Dim::_3D) {
-          flds_bc_enum.push_back({ FldsBC::PERIODIC, FldsBC::PERIODIC });
-        }
-        prtl_bc_enum.push_back(
-          { PrtlBC::HORIZON, PrtlBC::pick(fmt::toLower(prtl_bc[0][0]).c_str()) });
-        prtl_bc_enum.push_back({ PrtlBC::AXIS, PrtlBC::AXIS });
-        if (dim == Dim::_3D) {
-          prtl_bc_enum.push_back({ PrtlBC::PERIODIC, PrtlBC::PERIODIC });
-        }
-      }
-    }
-
-    raise::ErrorIf(flds_bc_enum.size() != (std::size_t)dim,
-                   "invalid inferred `grid.boundaries.fields`",
-                   HERE);
-    raise::ErrorIf(prtl_bc_enum.size() != (std::size_t)dim,
-                   "invalid inferred `grid.boundaries.particles`",
-                   HERE);
-    boundaries_t<FldsBC> flds_bc_pairwise;
-    boundaries_t<PrtlBC> prtl_bc_pairwise;
-    for (auto d { 0u }; d < (dim_t)dim; ++d) {
-      raise::ErrorIf(
-        flds_bc_enum[d].size() != 2,
-        fmt::format("invalid inferred `grid.boundaries.fields[%d]`", d),
-        HERE);
-      raise::ErrorIf(
-        prtl_bc_enum[d].size() != 2,
-        fmt::format("invalid inferred `grid.boundaries.particles[%d]`", d),
-        HERE);
-      flds_bc_pairwise.push_back({ flds_bc_enum[d][0], flds_bc_enum[d][1] });
-      prtl_bc_pairwise.push_back({ prtl_bc_enum[d][0], prtl_bc_enum[d][1] });
-    }
-    set("grid.boundaries.fields", flds_bc_pairwise);
-    set("grid.boundaries.particles", prtl_bc_pairwise);
-
-    if (isPromised("grid.boundaries.match.ds")) {
-      if (coord_enum == Coord::Cart) {
-        auto min_extent = std::numeric_limits<real_t>::max();
-        for (const auto& e : extent_pairwise) {
-          min_extent = std::min(min_extent, e.second - e.first);
-        }
-        const auto default_ds = min_extent * defaults::bc::match::ds_frac;
-        boundaries_t<real_t> ds_array;
-        try {
-          auto ds = toml::find<real_t>(toml_data, "grid", "boundaries", "match", "ds");
-          for (auto d = 0u; d < dim; ++d) {
-            ds_array.push_back({ ds, ds });
-          }
-        } catch (...) {
-          try {
-            const auto ds = toml::find<std::vector<std::vector<real_t>>>(
-              toml_data,
-              "grid",
-              "boundaries",
-              "match",
-              "ds");
-            raise::ErrorIf(ds.size() != dim,
-                           "invalid # in `grid.boundaries.match.ds`",
-                           HERE);
-            for (auto d = 0u; d < dim; ++d) {
-              if (ds[d].size() == 1) {
-                ds_array.push_back({ ds[d][0], ds[d][0] });
-              } else if (ds[d].size() == 2) {
-                ds_array.push_back({ ds[d][0], ds[d][1] });
-              } else if (ds[d].size() == 0) {
-                ds_array.push_back({});
-              } else {
-                raise::Error("invalid `grid.boundaries.match.ds`", HERE);
-              }
-            }
-          } catch (...) {
-            for (auto d = 0u; d < dim; ++d) {
-              ds_array.push_back({ default_ds, default_ds });
-            }
-          }
-        }
-        set("grid.boundaries.match.ds", ds_array);
-      } else {
-        auto r_extent = extent_pairwise[0].second - extent_pairwise[0].first;
-        const auto ds = toml::find_or<real_t>(
-          toml_data,
-          "grid",
-          "boundaries",
-          "match",
-          "ds",
-          r_extent * defaults::bc::match::ds_frac);
-        boundaries_t<real_t> ds_array {
-          { ds, ds }
-        };
-        set("grid.boundaries.match.ds", ds_array);
-      }
-    }
-
-    if (isPromised("grid.boundaries.absorb.ds")) {
-      if (coord_enum == Coord::Cart) {
-        auto min_extent = std::numeric_limits<real_t>::max();
-        for (const auto& e : extent_pairwise) {
-          min_extent = std::min(min_extent, e.second - e.first);
-        }
-        set("grid.boundaries.absorb.ds",
-            toml::find_or(toml_data,
-                          "grid",
-                          "boundaries",
-                          "absorb",
-                          "ds",
-                          min_extent * defaults::bc::absorb::ds_frac));
-      } else {
-        auto r_extent = extent_pairwise[0].second - extent_pairwise[0].first;
-        set("grid.boundaries.absorb.ds",
-            toml::find_or(toml_data,
-                          "grid",
-                          "boundaries",
-                          "absorb",
-                          "ds",
-                          r_extent * defaults::bc::absorb::ds_frac));
-      }
-    }
-
-    if (isPromised("grid.boundaries.atmosphere.temperature")) {
-      const auto atm_T = toml::find<real_t>(toml_data,
-                                            "grid",
-                                            "boundaries",
-                                            "atmosphere",
-                                            "temperature");
-      const auto atm_h = toml::find<real_t>(toml_data,
-                                            "grid",
-                                            "boundaries",
-                                            "atmosphere",
-                                            "height");
-      set("grid.boundaries.atmosphere.temperature", atm_T);
-      set("grid.boundaries.atmosphere.density",
-          toml::find<real_t>(toml_data, "grid", "boundaries", "atmosphere", "density"));
-      set("grid.boundaries.atmosphere.ds",
-          toml::find_or(toml_data, "grid", "boundaries", "atmosphere", "ds", ZERO));
-      set("grid.boundaries.atmosphere.height", atm_h);
-      set("grid.boundaries.atmosphere.g", atm_T / atm_h);
-      const auto atm_species = toml::find<std::pair<spidx_t, spidx_t>>(
-        toml_data,
-        "grid",
-        "boundaries",
-        "atmosphere",
-        "species");
-      set("grid.boundaries.atmosphere.species", atm_species);
-    }
-
-    // gca
-    if (isPromised("algorithms.gca.e_ovr_b_max")) {
-      set("algorithms.gca.e_ovr_b_max",
-          toml::find_or(toml_data,
-                        "algorithms",
-                        "gca",
-                        "e_ovr_b_max",
-                        defaults::gca::EovrB_max));
-      set("algorithms.gca.larmor_max",
-          toml::find_or(toml_data, "algorithms", "gca", "larmor_max", ZERO));
-    }
-
-    // cooling
-    if (isPromised("algorithms.synchrotron.gamma_rad")) {
-      set("algorithms.synchrotron.gamma_rad",
-          toml::find_or(toml_data,
-                        "algorithms",
-                        "synchrotron",
-                        "gamma_rad",
-                        defaults::synchrotron::gamma_rad));
-    }
-    if (isPromised("algorithms.compton.gamma_rad")) {
-      set("algorithms.compton.gamma_rad",
-          toml::find_or(toml_data,
-                        "algorithms",
-                        "compton",
-                        "gamma_rad",
-                        defaults::compton::gamma_rad));
-    }
-
-    // @TODO: disabling stats for non-Cartesian
-    if (coord_enum != Coord::Cart) {
-      set("output.stats.enable", false);
-    }
-  }
-
-  void SimulationParams::setSetupParams(const toml::value& toml_data) {
-    /* [setup] -------------------------------------------------------------- */
-    const auto setup = toml::find_or(toml_data, "setup", toml::table {});
-    for (const auto& [key, val] : setup) {
-      if (val.is_boolean()) {
-        set("setup." + key, (bool)(val.as_boolean()));
-      } else if (val.is_integer()) {
-        set("setup." + key, (int)(val.as_integer()));
-      } else if (val.is_floating()) {
-        set("setup." + key, (real_t)(val.as_floating()));
-      } else if (val.is_string()) {
-        set("setup." + key, (std::string)(val.as_string()));
-      } else if (val.is_array()) {
-        const auto val_arr = val.as_array();
-        if (val_arr.size() == 0) {
-          continue;
-        } else {
-          if (val_arr[0].is_integer()) {
-            std::vector<int> vec;
-            for (const auto& v : val_arr) {
-              vec.push_back(v.as_integer());
-            }
-            set("setup." + key, vec);
-          } else if (val_arr[0].is_floating()) {
-            std::vector<real_t> vec;
-            for (const auto& v : val_arr) {
-              vec.push_back(v.as_floating());
-            }
-            set("setup." + key, vec);
-          } else if (val_arr[0].is_boolean()) {
-            std::vector<bool> vec;
-            for (const auto& v : val_arr) {
-              vec.push_back(v.as_boolean());
-            }
-            set("setup." + key, vec);
-          } else if (val_arr[0].is_string()) {
-            std::vector<std::string> vec;
-            for (const auto& v : val_arr) {
-              vec.push_back(v.as_string());
-            }
-            set("setup." + key, vec);
-          } else if (val_arr[0].is_array()) {
-            raise::Error("only 1D arrays allowed in [setup]", HERE);
-          } else {
-            raise::Error("invalid setup variable type", HERE);
-          }
-        }
-      }
-    }
-  }
-
-  void SimulationParams::setCheckpointParams(bool       is_resuming,
-                                             timestep_t start_step,
-                                             simtime_t  start_time) {
-    set("checkpoint.is_resuming", is_resuming);
-    set("checkpoint.start_step", start_step);
-    set("checkpoint.start_time", start_time);
-  }
-
-  void SimulationParams::checkPromises() const {
-    raise::ErrorIf(!promisesFulfilled(),
-                   "Have not defined all the necessary variables",
-                   HERE);
-  }
-
-  void SimulationParams::saveTOML(const std::string& path, simtime_t time) const {
-    CallOnce([&]() {
-      std::ofstream metadata;
-      metadata.open(path);
-      metadata << fmt::format("[metadata]\n  time = %f\n\n", time) << data()
-               << std::endl;
-      metadata.close();
-    });
-  }
-
-} // namespace ntt
diff --git a/src/framework/parameters/algorithms.cpp b/src/framework/parameters/algorithms.cpp
new file mode 100644
index 000000000..944c323f8
--- /dev/null
+++ b/src/framework/parameters/algorithms.cpp
@@ -0,0 +1,157 @@
+#include "framework/parameters/algorithms.h"
+
+#include "defaults.h"
+#include "global.h"
+
+#include "utils/numeric.h"
+#include <toml11/toml.hpp>
+
+#include "framework/parameters/parameters.h"
+
+namespace ntt {
+  namespace params {
+
+    void Algorithms::read(real_t                             dx0,
+                          const std::map<std::string, bool>& extra,
+                          const toml::value&                 toml_data) {
+      CFL = toml::find_or(toml_data, "algorithms", "timestep", "CFL", defaults::cfl);
+      dt                   = CFL * dx0;
+      dt_correction_factor = toml::find_or(toml_data,
+                                           "algorithms",
+                                           "timestep",
+                                           "correction",
+                                           defaults::correction);
+
+      number_of_current_filters = toml::find_or(toml_data,
+                                                "algorithms",
+                                                "current_filters",
+                                                defaults::current_filters);
+
+      deposit_enable = toml::find_or(toml_data, "algorithms", "deposit", "enable", true);
+      deposit_order = static_cast<unsigned short>(SHAPE_ORDER);
+
+      fieldsolver_enable = toml::find_or(toml_data,
+                                         "algorithms",
+                                         "fieldsolver",
+                                         "enable",
+                                         true);
+
+      fieldsolver_stencil_coeffs["delta_x"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "delta_x",
+        defaults::fieldsolver::delta_x);
+
+      fieldsolver_stencil_coeffs["delta_y"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "delta_y",
+        defaults::fieldsolver::delta_y);
+
+      fieldsolver_stencil_coeffs["delta_z"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "delta_z",
+        defaults::fieldsolver::delta_z);
+
+      fieldsolver_stencil_coeffs["beta_xy"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_xy",
+        defaults::fieldsolver::beta_xy);
+
+      fieldsolver_stencil_coeffs["beta_yx"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_yx",
+        defaults::fieldsolver::beta_yx);
+
+      fieldsolver_stencil_coeffs["beta_xz"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_xz",
+        defaults::fieldsolver::beta_xz);
+
+      fieldsolver_stencil_coeffs["beta_zx"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_zx",
+        defaults::fieldsolver::beta_zx);
+
+      fieldsolver_stencil_coeffs["beta_yz"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_yz",
+        defaults::fieldsolver::beta_yz);
+
+      fieldsolver_stencil_coeffs["beta_zy"] = toml::find_or(
+        toml_data,
+        "algorithms",
+        "fieldsolver",
+        "beta_zy",
+        defaults::fieldsolver::beta_zy);
+
+      if (extra.at("gr")) {
+        gr_pusher_eps   = toml::find_or(toml_data,
+                                      "algorithms",
+                                      "gr",
+                                      "pusher_eps",
+                                      defaults::gr::pusher_eps);
+        gr_pusher_niter = toml::find_or(toml_data,
+                                        "algorithms",
+                                        "gr",
+                                        "pusher_niter",
+                                        defaults::gr::pusher_niter);
+      }
+
+      if (extra.at("gca")) {
+        gca_e_ovr_b_max = toml::find_or(toml_data,
+                                        "algorithms",
+                                        "gca",
+                                        "e_ovr_b_max",
+                                        defaults::gca::EovrB_max);
+        gca_larmor_max  = toml::find_or(toml_data,
+                                       "algorithms",
+                                       "gca",
+                                       "larmor_max",
+                                       ZERO);
+      }
+    }
+
+    void Algorithms::setParams(const std::map<std::string, bool>& extra,
+                               SimulationParams* params) const {
+      params->set("algorithms.timestep.CFL", CFL);
+      params->set("algorithms.timestep.dt", dt);
+      params->set("algorithms.timestep.correction", dt_correction_factor);
+
+      params->set("algorithms.current_filters", number_of_current_filters);
+
+      params->set("algorithms.deposit.enable", deposit_enable);
+      params->set("algorithms.deposit.order", deposit_order);
+
+      params->set("algorithms.fieldsolver.enable", fieldsolver_enable);
+      for (const auto& [key, value] : fieldsolver_stencil_coeffs) {
+        params->set("algorithms.fieldsolver." + key, value);
+      }
+
+      if (extra.at("gr")) {
+        params->set("algorithms.gr.pusher_eps", gr_pusher_eps);
+        params->set("algorithms.gr.pusher_niter", gr_pusher_niter);
+      }
+
+      if (extra.at("gca")) {
+        params->set("algorithms.gca.e_ovr_b_max", gca_e_ovr_b_max);
+        params->set("algorithms.gca.larmor_max", gca_larmor_max);
+      }
+    }
+
+  } // namespace params
+} // namespace ntt
diff --git a/src/framework/parameters/algorithms.h b/src/framework/parameters/algorithms.h
new file mode 100644
index 000000000..fb41d731c
--- /dev/null
+++ b/src/framework/parameters/algorithms.h
@@ -0,0 +1,56 @@
+/**
+ * @file framework/parameters/algorithms.h
+ * @brief Auxiliary functions for reading in algorithms parameters
+ * @implements
+ *   - ntt::params::Algorithms
+ * @cpp:
+ *   - algorithms.cpp
+ * @namespaces:
+ *   - ntt::params::
+ */
+
+#ifndef FRAMEWORK_PARAMETERS_ALGORITHMS_H
+#define FRAMEWORK_PARAMETERS_ALGORITHMS_H
+
+#include "global.h"
+
+#include <toml11/toml.hpp>
+
+#include "framework/parameters/parameters.h"
+
+#include <map>
+#include <string>
+
+namespace ntt {
+  namespace params {
+
+    struct Algorithms {
+      real_t CFL;
+      real_t dt;
+      real_t dt_correction_factor;
+
+      unsigned short number_of_current_filters;
+
+      bool           deposit_enable;
+      unsigned short deposit_order;
+
+      bool                          fieldsolver_enable;
+      std::map<std::string, real_t> fieldsolver_stencil_coeffs;
+
+      real_t         gr_pusher_eps;
+      unsigned short gr_pusher_niter;
+
+      real_t gca_e_ovr_b_max;
+      real_t gca_larmor_max;
+
+      real_t synchrotron_gamma_rad;
+      real_t compton_gamma_rad;
+
+      void read(real_t, const std::map<std::string, bool>&, const toml::value&);
+      void setParams(const std::map<std::string, bool>&, SimulationParams*) const;
+    };
+
+  } // namespace params
+} // namespace ntt
+
+#endif // FRAMEWORK_PARAMETERS_ALGORITHMS_H
diff --git a/src/framework/parameters/extra.cpp b/src/framework/parameters/extra.cpp
new file mode 100644
index 000000000..3e8c2dcd9
--- /dev/null
+++ b/src/framework/parameters/extra.cpp
@@ -0,0 +1,153 @@
+#include "framework/parameters/extra.h"
+
+#include "defaults.h"
+
+#include "utils/numeric.h"
+
+namespace ntt {
+  namespace params {
+
+    void Extra::read(const std::map<std::string, bool>& extra,
+                     const toml::value&                 toml_data,
+                     const SimulationParams* const      params) {
+      if (extra.at("synchrotron_drag")) {
+        synchrotron_gamma_rad = toml::find_or(toml_data,
+                                              "radiation",
+                                              "drag",
+                                              "synchrotron",
+                                              "gamma_rad",
+                                              defaults::synchrotron::gamma_rad);
+      }
+
+      if (extra.at("compton_drag")) {
+        compton_gamma_rad = toml::find_or(toml_data,
+                                          "radiation",
+                                          "drag",
+                                          "compton",
+                                          "gamma_rad",
+                                          defaults::compton::gamma_rad);
+      }
+
+      if (extra.at("synchrotron_emission")) {
+        synchrotron_gamma_rad      = toml::find_or(toml_data,
+                                              "radiation",
+                                              "drag",
+                                              "synchrotron",
+                                              "gamma_rad",
+                                              defaults::synchrotron::gamma_rad);
+        synchrotron_gamma_qed      = toml::find_or(toml_data,
+                                              "radiation",
+                                              "emission",
+                                              "synchrotron",
+                                              "gamma_qed",
+                                              defaults::synchrotron::gamma_qed);
+        synchrotron_energy_min     = toml::find_or(toml_data,
+                                               "radiation",
+                                               "emission",
+                                               "synchrotron",
+                                               "photon_energy_min",
+                                               defaults::synchrotron::energy_min);
+        synchrotron_photon_weight  = toml::find_or(toml_data,
+                                                  "radiation",
+                                                  "emission",
+                                                  "synchrotron",
+                                                  "photon_weight",
+                                                  ONE);
+        synchrotron_photon_species = toml::find<spidx_t>(toml_data,
+                                                         "radiation",
+                                                         "emission",
+                                                         "synchrotron",
+                                                         "photon_species");
+        synchrotron_nominal_probability =
+          params->template get<real_t>("scales.omegaB0") *
+          static_cast<real_t>(0.1) *
+          params->template get<real_t>("algorithms.timestep.dt") *
+          SQR(synchrotron_gamma_qed / synchrotron_gamma_rad) /
+          synchrotron_photon_weight;
+        synchrotron_nominal_photon_energy = ONE / SQR(synchrotron_gamma_qed);
+      }
+
+      if (extra.at("compton_emission")) {
+        compton_gamma_rad           = toml::find_or(toml_data,
+                                          "radiation",
+                                          "drag",
+                                          "compton",
+                                          "gamma_rad",
+                                          defaults::compton::gamma_rad);
+        compton_gamma_qed           = toml::find_or(toml_data,
+                                          "radiation",
+                                          "emission",
+                                          "compton",
+                                          "gamma_qed",
+                                          defaults::compton::gamma_qed);
+        compton_energy_min          = toml::find_or(toml_data,
+                                           "radiation",
+                                           "emission",
+                                           "compton",
+                                           "photon_energy_min",
+                                           defaults::compton::energy_min);
+        compton_photon_weight       = toml::find_or(toml_data,
+                                              "radiation",
+                                              "emission",
+                                              "compton",
+                                              "photon_weight",
+                                              ONE);
+        compton_photon_species      = toml::find<spidx_t>(toml_data,
+                                                     "radiation",
+                                                     "emission",
+                                                     "compton",
+                                                     "photon_species");
+        compton_nominal_probability = params->template get<real_t>(
+                                        "scales.omegaB0") *
+                                      static_cast<real_t>(0.1) *
+                                      params->template get<real_t>(
+                                        "algorithms.timestep.dt") *
+                                      SQR(compton_gamma_qed / compton_gamma_rad) /
+                                      compton_photon_weight;
+        compton_nominal_photon_energy = ONE / SQR(compton_gamma_qed);
+      }
+    }
+
+    void Extra::setParams(const std::map<std::string, bool>& extra,
+                          SimulationParams*                  params) const {
+      if (extra.at("synchrotron_drag")) {
+        params->set("radiation.drag.synchrotron.gamma_rad", synchrotron_gamma_rad);
+      }
+
+      if (extra.at("compton_drag")) {
+        params->set("radiation.drag.compton.gamma_rad", compton_gamma_rad);
+      }
+
+      if (extra.at("synchrotron_emission")) {
+        params->set("radiation.drag.synchrotron.gamma_rad", synchrotron_gamma_rad);
+        params->set("radiation.emission.synchrotron.gamma_qed",
+                    synchrotron_gamma_qed);
+        params->set("radiation.emission.synchrotron.photon_energy_min",
+                    synchrotron_energy_min);
+        params->set("radiation.emission.synchrotron.photon_weight",
+                    synchrotron_photon_weight);
+        params->set("radiation.emission.synchrotron.photon_species",
+                    synchrotron_photon_species);
+        params->set("radiation.emission.synchrotron.nominal_probability",
+                    synchrotron_nominal_probability);
+        params->set("radiation.emission.synchrotron.nominal_photon_energy",
+                    synchrotron_nominal_photon_energy);
+      }
+
+      if (extra.at("compton_emission")) {
+        params->set("radiation.drag.compton.gamma_rad", compton_gamma_rad);
+        params->set("radiation.emission.compton.gamma_qed", compton_gamma_qed);
+        params->set("radiation.emission.compton.photon_energy_min",
+                    compton_energy_min);
+        params->set("radiation.emission.compton.photon_weight",
+                    compton_photon_weight);
+        params->set("radiation.emission.compton.photon_species",
+                    compton_photon_species);
+        params->set("radiation.emission.compton.nominal_probability",
+                    compton_nominal_probability);
+        params->set("radiation.emission.compton.nominal_photon_energy",
+                    compton_nominal_photon_energy);
+      }
+    }
+  } // namespace params
+} // namespace ntt
diff --git a/src/framework/parameters/extra.h b/src/framework/parameters/extra.h
new file mode 100644
index 000000000..cec6f619b
--- /dev/null
+++ b/src/framework/parameters/extra.h
@@ -0,0 +1,56 @@
+/**
+ * @file framework/parameters/algorithms.h
+ * @brief Auxiliary functions for reading in extra physics parameters
+ * @implements
+ *   - ntt::params::Extra
+ * @cpp:
+ *   - extra.cpp
+ * @namespaces:
+ *   - ntt::params::
+ */
+
+#ifndef FRAMEWORK_PARAMETERS_EXTRA_H
+#define FRAMEWORK_PARAMETERS_EXTRA_H
+
+#include "global.h"
+
+#include <toml11/toml.hpp>
+
+#include "framework/parameters/parameters.h"
+
+#include <map>
+#include <string>
+
+namespace ntt {
+  namespace params {
+
+    struct Extra {
+      // radiative drag parameters
+      real_t synchrotron_gamma_rad;
+      real_t compton_gamma_rad;
+
+      // emission parameters
+      real_t  synchrotron_energy_min;
+      real_t  synchrotron_gamma_qed;
+      real_t  synchrotron_photon_weight;
+      spidx_t synchrotron_photon_species;
+      real_t  synchrotron_nominal_probability;
+      real_t  synchrotron_nominal_photon_energy;
+
+      real_t  compton_energy_min;
+      real_t  compton_gamma_qed;
+      real_t  compton_photon_weight;
+      spidx_t compton_photon_species;
+      real_t  compton_nominal_probability;
+      real_t  compton_nominal_photon_energy;
+
+      void read(const std::map<std::string, bool>&,
+                const toml::value&,
+                const SimulationParams* const);
+      void setParams(const std::map<std::string, bool>&, SimulationParams*) const;
+    };
+
+  } // namespace params
+} // namespace ntt
+
+#endif // FRAMEWORK_PARAMETERS_EXTRA_H
diff --git a/src/framework/parameters/grid.cpp b/src/framework/parameters/grid.cpp
new file mode 100644
index 000000000..78072680f
--- /dev/null
+++ b/src/framework/parameters/grid.cpp
@@ -0,0 +1,551 @@
+#include "framework/parameters/grid.h"
+
+#include "defaults.h"
+#include "global.h"
+
+#include "utils/error.h"
+#include "utils/formatting.h"
+#include "utils/numeric.h"
+#include <toml11/toml.hpp>
+
+#include "metrics/kerr_schild.h"
+#include "metrics/kerr_schild_0.h"
+#include "metrics/minkowski.h"
+#include "metrics/qkerr_schild.h"
+#include "metrics/qspherical.h"
+#include "metrics/spherical.h"
+
+#include "framework/parameters/parameters.h"
+
+#include <map>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace ntt {
+  namespace params {
+
+    template <typename M>
+    auto get_dx0_V0(const std::vector<ncells_t>&         resolution,
+                    const boundaries_t<real_t>&          extent,
+                    const std::map<std::string, real_t>& params)
+      -> std::pair<real_t, real_t> {
+      const auto      metric = M(resolution, extent, params);
+      const auto      dx0    = metric.dxMin();
+      coord_t<M::Dim> x_corner { ZERO };
+      for (auto d { 0u }; d < M::Dim; ++d) {
+        x_corner[d] = HALF;
+      }
+      const auto V0 = metric.sqrt_det_h(x_corner);
+      return { dx0, V0 };
+    }
+
+    auto GetBoundaryConditions(SimulationParams*  params,
+                               const SimEngine&   engine_enum,
+                               Dimension          dim,
+                               const Coord&       coord_enum,
+                               const toml::value& toml_data)
+      -> std::tuple<boundaries_t<FldsBC>, boundaries_t<PrtlBC>> {
+      auto flds_bc = toml::find<std::vector<std::vector<std::string>>>(
+        toml_data,
+        "grid",
+        "boundaries",
+        "fields");
+      {
+        raise::ErrorIf(flds_bc.size() < 1 || flds_bc.size() > 3,
+                       "invalid `grid.boundaries.fields`",
+                       HERE);
+        params->promiseToDefine("grid.boundaries.fields");
+        auto atm_defined = false;
+        for (const auto& bcs : flds_bc) {
+          for (const auto& bc : bcs) {
+            if (fmt::toLower(bc) == "match") {
+              params->promiseToDefine("grid.boundaries.match.ds");
+            }
+            if (fmt::toLower(bc) == "atmosphere") {
+              raise::ErrorIf(atm_defined,
+                             "ATMOSPHERE is only allowed in one direction",
+                             HERE);
+              atm_defined = true;
+              params->promiseToDefine("grid.boundaries.atmosphere.temperature");
+              params->promiseToDefine("grid.boundaries.atmosphere.density");
+              params->promiseToDefine("grid.boundaries.atmosphere.height");
+              params->promiseToDefine("grid.boundaries.atmosphere.ds");
+              params->promiseToDefine("grid.boundaries.atmosphere.species");
+              params->promiseToDefine("grid.boundaries.atmosphere.g");
+            }
+          }
+        }
+      }
+
+      auto prtl_bc = toml::find<std::vector<std::vector<std::string>>>(
+        toml_data,
+        "grid",
+        "boundaries",
+        "particles");
+      {
+        raise::ErrorIf(prtl_bc.size() < 1 || prtl_bc.size() > 3,
+                       "invalid `grid.boundaries.particles`",
+                       HERE);
+        params->promiseToDefine("grid.boundaries.particles");
+        auto atm_defined = false;
+        for (const auto& bcs : prtl_bc) {
+          for (const auto& bc : bcs) {
+            if (fmt::toLower(bc) == "absorb") {
+              params->promiseToDefine("grid.boundaries.absorb.ds");
+            }
+            if (fmt::toLower(bc) == "atmosphere") {
+              raise::ErrorIf(atm_defined,
+                             "ATMOSPHERE is only allowed in one direction",
+                             HERE);
+              atm_defined = true;
+              params->promiseToDefine("grid.boundaries.atmosphere.temperature");
+              params->promiseToDefine("grid.boundaries.atmosphere.density");
+              params->promiseToDefine("grid.boundaries.atmosphere.height");
+              params->promiseToDefine("grid.boundaries.atmosphere.ds");
+              params->promiseToDefine("grid.boundaries.atmosphere.species");
+              params->promiseToDefine("grid.boundaries.atmosphere.g");
+            }
+          }
+        }
+      }
+      std::vector<std::vector<FldsBC>> flds_bc_enum;
+      std::vector<std::vector<PrtlBC>> prtl_bc_enum;
+      if (coord_enum == Coord::Cart) {
+        raise::ErrorIf(flds_bc.size() != (std::size_t)dim,
+                       "invalid `grid.boundaries.fields`",
+                       HERE);
+        raise::ErrorIf(prtl_bc.size() != (std::size_t)dim,
+                       "invalid `grid.boundaries.particles`",
+                       HERE);
+        for (auto d { 0u }; d < (dim_t)dim; ++d) {
+          flds_bc_enum.push_back({});
+          prtl_bc_enum.push_back({});
+          const auto fbc = flds_bc[d];
+          const auto pbc = prtl_bc[d];
+          raise::ErrorIf(fbc.size() < 1 || fbc.size() > 2,
+                         "invalid `grid.boundaries.fields`",
+                         HERE);
+          raise::ErrorIf(pbc.size() < 1 || pbc.size() > 2,
+                         "invalid `grid.boundaries.particles`",
+                         HERE);
+          auto fbc_enum = FldsBC::pick(fmt::toLower(fbc[0]).c_str());
+          auto pbc_enum = PrtlBC::pick(fmt::toLower(pbc[0]).c_str());
+          if (fbc.size() == 1) {
+            raise::ErrorIf(fbc_enum != FldsBC::PERIODIC,
+                           "invalid `grid.boundaries.fields`",
+                           HERE);
+            flds_bc_enum.back().push_back(FldsBC(FldsBC::PERIODIC));
+            flds_bc_enum.back().push_back(FldsBC(FldsBC::PERIODIC));
+          } else {
+            raise::ErrorIf(fbc_enum == FldsBC::PERIODIC,
+                           "invalid `grid.boundaries.fields`",
+                           HERE);
+            flds_bc_enum.back().push_back(fbc_enum);
+            auto fbc_enum = FldsBC::pick(fmt::toLower(fbc[1]).c_str());
+            raise::ErrorIf(fbc_enum == FldsBC::PERIODIC,
+                           "invalid `grid.boundaries.fields`",
+                           HERE);
+            flds_bc_enum.back().push_back(fbc_enum);
+          }
+          if (pbc.size() == 1) {
+            raise::ErrorIf(pbc_enum != PrtlBC::PERIODIC,
+                           "invalid `grid.boundaries.particles`",
+                           HERE);
+            prtl_bc_enum.back().push_back(PrtlBC(PrtlBC::PERIODIC));
+            prtl_bc_enum.back().push_back(PrtlBC(PrtlBC::PERIODIC));
+          } else {
+            raise::ErrorIf(pbc_enum == PrtlBC::PERIODIC,
+                           "invalid `grid.boundaries.particles`",
+                           HERE);
+            prtl_bc_enum.back().push_back(pbc_enum);
+            auto pbc_enum = PrtlBC::pick(fmt::toLower(pbc[1]).c_str());
+            raise::ErrorIf(pbc_enum == PrtlBC::PERIODIC,
+                           "invalid `grid.boundaries.particles`",
+                           HERE);
+            prtl_bc_enum.back().push_back(pbc_enum);
+          }
+        }
+      } else {
+        raise::ErrorIf(flds_bc.size() > 1, "invalid `grid.boundaries.fields`", HERE);
+        raise::ErrorIf(prtl_bc.size() > 1,
+                       "invalid `grid.boundaries.particles`",
+                       HERE);
+        if (engine_enum == SimEngine::SRPIC) {
+          raise::ErrorIf(flds_bc[0].size() != 2,
+                         "invalid `grid.boundaries.fields`",
+                         HERE);
+          flds_bc_enum.push_back(
+            { FldsBC::pick(fmt::toLower(flds_bc[0][0]).c_str()),
+              FldsBC::pick(fmt::toLower(flds_bc[0][1]).c_str()) });
+          flds_bc_enum.push_back({ FldsBC::AXIS, FldsBC::AXIS });
+          if (dim == Dim::_3D) {
+            flds_bc_enum.push_back({ FldsBC::PERIODIC, FldsBC::PERIODIC });
+          }
+          raise::ErrorIf(prtl_bc[0].size() != 2,
+                         "invalid `grid.boundaries.particles`",
+                         HERE);
+          prtl_bc_enum.push_back(
+            { PrtlBC::pick(fmt::toLower(prtl_bc[0][0]).c_str()),
+              PrtlBC::pick(fmt::toLower(prtl_bc[0][1]).c_str()) });
+          prtl_bc_enum.push_back({ PrtlBC::AXIS, PrtlBC::AXIS });
+          if (dim == Dim::_3D) {
+            prtl_bc_enum.push_back({ PrtlBC::PERIODIC, PrtlBC::PERIODIC });
+          }
+        } else {
+          raise::ErrorIf(flds_bc[0].size() != 1,
+                         "invalid `grid.boundaries.fields`",
+                         HERE);
+          raise::ErrorIf(prtl_bc[0].size() != 1,
+                         "invalid `grid.boundaries.particles`",
+                         HERE);
+          flds_bc_enum.push_back(
+            { FldsBC::HORIZON, FldsBC::pick(fmt::toLower(flds_bc[0][0]).c_str()) });
+          flds_bc_enum.push_back({ FldsBC::AXIS, FldsBC::AXIS });
+          if (dim == Dim::_3D) {
+            flds_bc_enum.push_back({ FldsBC::PERIODIC, FldsBC::PERIODIC });
+          }
+          prtl_bc_enum.push_back(
+            { PrtlBC::HORIZON, PrtlBC::pick(fmt::toLower(prtl_bc[0][0]).c_str()) });
+          prtl_bc_enum.push_back({ PrtlBC::AXIS, PrtlBC::AXIS });
+          if (dim == Dim::_3D) {
+            prtl_bc_enum.push_back({ PrtlBC::PERIODIC, PrtlBC::PERIODIC });
+          }
+        }
+      }
+
+      raise::ErrorIf(flds_bc_enum.size() != (std::size_t)dim,
+                     "invalid inferred `grid.boundaries.fields`",
+                     HERE);
+      raise::ErrorIf(prtl_bc_enum.size() != (std::size_t)dim,
+                     "invalid inferred `grid.boundaries.particles`",
+                     HERE);
+      boundaries_t<FldsBC> flds_bc_pairwise;
+      boundaries_t<PrtlBC> prtl_bc_pairwise;
+      for (auto d { 0u }; d < (dim_t)dim; ++d) {
+        raise::ErrorIf(
+          flds_bc_enum[d].size() != 2,
+          fmt::format("invalid inferred `grid.boundaries.fields[%d]`", d),
+          HERE);
+        raise::ErrorIf(
+          prtl_bc_enum[d].size() != 2,
+          fmt::format("invalid inferred `grid.boundaries.particles[%d]`", d),
+          HERE);
+        flds_bc_pairwise.push_back({ flds_bc_enum[d][0], flds_bc_enum[d][1] });
+        prtl_bc_pairwise.push_back({ prtl_bc_enum[d][0], prtl_bc_enum[d][1] });
+      }
+      return { flds_bc_pairwise, prtl_bc_pairwise };
+    }
+
+    void Boundaries::read(Dimension                   dim,
+                          const Coord&                coord_enum,
+                          const boundaries_t<real_t>& extent_pairwise,
+                          const toml::value&          toml_data) {
+      if (needs_match_boundaries) {
+        if (coord_enum == Coord::Cart) {
+          auto min_extent = std::numeric_limits<real_t>::max();
+          for (const auto& e : extent_pairwise) {
+            min_extent = std::min(min_extent, e.second - e.first);
+          }
+          const auto default_ds = min_extent * defaults::bc::match::ds_frac;
+          try {
+            auto ds = toml::find<real_t>(toml_data, "grid", "boundaries", "match", "ds");
+            for (auto d = 0u; d < dim; ++d) {
+              match_ds_array.push_back({ ds, ds });
+            }
+          } catch (...) {
+            try {
+              const auto ds = toml::find<std::vector<std::vector<real_t>>>(
+                toml_data,
+                "grid",
+                "boundaries",
+                "match",
+                "ds");
+              raise::ErrorIf(ds.size() != dim,
+                             "invalid # in `grid.boundaries.match.ds`",
+                             HERE);
+              for (auto d = 0u; d < dim; ++d) {
+                if (ds[d].size() == 1) {
+                  match_ds_array.push_back({ ds[d][0], ds[d][0] });
+                } else if (ds[d].size() == 2) {
+                  match_ds_array.push_back({ ds[d][0], ds[d][1] });
+                } else if (ds[d].size() == 0) {
+                  match_ds_array.push_back({});
+                } else {
+                  raise::Error("invalid `grid.boundaries.match.ds`", HERE);
+                }
+              }
+            } catch (...) {
+              for (auto d = 0u; d < dim; ++d) {
+                match_ds_array.push_back({ default_ds, default_ds });
+              }
+            }
+          }
+        } else {
+          auto r_extent = extent_pairwise[0].second - extent_pairwise[0].first;
+          const auto ds = toml::find_or<real_t>(
+            toml_data,
+            "grid",
+            "boundaries",
+            "match",
+            "ds",
+            r_extent * defaults::bc::match::ds_frac);
+          match_ds_array.push_back({ ds, ds });
+        }
+      }
+
+      if (needs_absorb_boundaries) {
+        if (coord_enum == Coord::Cart) {
+          auto min_extent = std::numeric_limits<real_t>::max();
+          for (const auto& e : extent_pairwise) {
+            min_extent = std::min(min_extent, e.second - e.first);
+          }
+          absorb_ds = toml::find_or(toml_data,
+                                    "grid",
+                                    "boundaries",
+                                    "absorb",
+                                    "ds",
+                                    min_extent * defaults::bc::absorb::ds_frac);
+        } else {
+          auto r_extent = extent_pairwise[0].second - extent_pairwise[0].first;
+          absorb_ds     = toml::find_or(toml_data,
+                                    "grid",
+                                    "boundaries",
+                                    "absorb",
+                                    "ds",
+                                    r_extent * defaults::bc::absorb::ds_frac);
+        }
+      }
+
+      if (needs_atmosphere_boundaries) {
+        atmosphere_temperature = toml::find<real_t>(toml_data,
+                                                    "grid",
+                                                    "boundaries",
+                                                    "atmosphere",
+                                                    "temperature");
+        atmosphere_height      = toml::find<real_t>(toml_data,
+                                               "grid",
+                                               "boundaries",
+                                               "atmosphere",
+                                               "height");
+        atmosphere_density     = toml::find<real_t>(toml_data,
+                                                "grid",
+                                                "boundaries",
+                                                "atmosphere",
+                                                "density");
+        atmosphere_ds =
+          toml::find_or(toml_data, "grid", "boundaries", "atmosphere", "ds", ZERO);
+        atmosphere_g       = atmosphere_temperature / atmosphere_height;
+        atmosphere_species = toml::find<std::pair<spidx_t, spidx_t>>(
+          toml_data,
+          "grid",
+          "boundaries",
+          "atmosphere",
+          "species");
+      }
+    }
+
+    void Boundaries::setParams(SimulationParams* params) const {
+      if (needs_match_boundaries) {
+        params->set("grid.boundaries.match.ds", match_ds_array);
+      }
+      if (needs_absorb_boundaries) {
+        params->set("grid.boundaries.absorb.ds", absorb_ds);
+      }
+      if (needs_atmosphere_boundaries) {
+        params->set("grid.boundaries.atmosphere.temperature",
+                    atmosphere_temperature);
+        params->set("grid.boundaries.atmosphere.density", atmosphere_density);
+        params->set("grid.boundaries.atmosphere.height", atmosphere_height);
+        params->set("grid.boundaries.atmosphere.ds", atmosphere_ds);
+        params->set("grid.boundaries.atmosphere.g", atmosphere_g);
+        params->set("grid.boundaries.atmosphere.species", atmosphere_species);
+      }
+    }
+
+    void Grid::read(const SimEngine& engine_enum, const toml::value& toml_data) {
+      /* domain decomposition ------------------------------------------------ */
+      int default_ndomains = 1;
+#if defined(MPI_ENABLED)
+      raise::ErrorIf(MPI_Comm_size(MPI_COMM_WORLD, &default_ndomains) != MPI_SUCCESS,
+                     "MPI_Comm_size failed",
+                     HERE);
+#endif
+      number_of_domains = toml::find_or(toml_data,
+                                        "simulation",
+                                        "domain",
+                                        "number",
+                                        (unsigned int)default_ndomains);
+
+      domain_decomposition = toml::find_or<std::vector<int>>(
+        toml_data,
+        "simulation",
+        "domain",
+        "decomposition",
+        std::vector<int> { -1, -1, -1 });
+
+      /* resolution and dimension ------------------------------------------- */
+      resolution = toml::find<std::vector<ncells_t>>(toml_data, "grid", "resolution");
+      raise::ErrorIf(resolution.size() < 1 || resolution.size() > 3,
+                     "invalid `grid.resolution`",
+                     HERE);
+      dim = static_cast<Dimension>(resolution.size());
+
+      if (domain_decomposition.size() > dim) {
+        domain_decomposition.erase(domain_decomposition.begin() + (std::size_t)(dim),
+                                   domain_decomposition.end());
+      }
+      raise::ErrorIf(domain_decomposition.size() != dim,
+                     "invalid `simulation.domain.decomposition`",
+                     HERE);
+
+      /* metric and coordinates -------------------------------------------- */
+      metric_enum = Metric::pick(
+        fmt::toLower(toml::find<std::string>(toml_data, "grid", "metric", "metric"))
+          .c_str());
+      std::string coord;
+      if (metric_enum == Metric::Minkowski) {
+        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
+                       "minkowski metric is only supported for SRPIC",
+                       HERE);
+        coord = "cart";
+      } else if (metric_enum == Metric::QKerr_Schild or
+                 metric_enum == Metric::QSpherical) {
+        // quasi-spherical geometry
+        raise::ErrorIf(dim == Dim::_1D,
+                       "not enough dimensions for qspherical geometry",
+                       HERE);
+        raise::ErrorIf(dim == Dim::_3D,
+                       "3D not implemented for qspherical geometry",
+                       HERE);
+        coord                    = "qsph";
+        metric_params["qsph_r0"] = toml::find_or(toml_data,
+                                                 "grid",
+                                                 "metric",
+                                                 "qsph_r0",
+                                                 defaults::qsph::r0);
+        metric_params["qsph_h"]  = toml::find_or(toml_data,
+                                                "grid",
+                                                "metric",
+                                                "qsph_h",
+                                                defaults::qsph::h);
+      } else {
+        // spherical geometry
+        raise::ErrorIf(dim == Dim::_1D,
+                       "not enough dimensions for spherical geometry",
+                       HERE);
+        raise::ErrorIf(dim == Dim::_3D,
+                       "3D not implemented for spherical geometry",
+                       HERE);
+        coord = "sph";
+      }
+      if ((engine_enum == SimEngine::GRPIC) &&
+          (metric_enum != Metric::Kerr_Schild_0)) {
+        const auto ks_a        = toml::find_or(toml_data,
+                                        "grid",
+                                        "metric",
+                                        "ks_a",
+                                        defaults::ks::a);
+        metric_params["ks_a"]  = ks_a;
+        metric_params["ks_rh"] = ONE + math::sqrt(ONE - SQR(ks_a));
+      }
+      coord_enum = Coord::pick(coord.c_str());
+
+      /* extent ------------------------------------------------------------- */
+      extent = toml::find<std::vector<std::vector<real_t>>>(toml_data,
+                                                            "grid",
+                                                            "extent");
+
+      if (extent.size() > dim) {
+        extent.erase(extent.begin() + (std::size_t)(dim), extent.end());
+      }
+      raise::ErrorIf(extent[0].size() != 2, "invalid `grid.extent[0]`", HERE);
+      if (coord_enum != Coord::Cart) {
+        raise::ErrorIf(extent.size() > 1,
+                       "invalid `grid.extent` for non-cartesian geometry",
+                       HERE);
+        extent.push_back({ ZERO, constant::PI });
+        if (dim == Dim::_3D) {
+          extent.push_back({ ZERO, TWO * constant::PI });
+        }
+      }
+      raise::ErrorIf(extent.size() != dim, "invalid inferred `grid.extent`", HERE);
+      for (auto d { 0u }; d < (dim_t)dim; ++d) {
+        raise::ErrorIf(extent[d].size() != 2,
+                       fmt::format("invalid inferred `grid.extent[%d]`", d),
+                       HERE);
+        extent_pairwise_.push_back({ extent[d][0], extent[d][1] });
+      }
+
+      /* metric parameters ------------------------------------------------------ */
+      if (coord_enum == Coord::Qsph) {
+        metric_params_short_["r0"] = metric_params["qsph_r0"];
+        metric_params_short_["h"]  = metric_params["qsph_h"];
+      }
+      if ((engine_enum == SimEngine::GRPIC) &&
+          (metric_enum != Metric::Kerr_Schild_0)) {
+        metric_params_short_["a"] = metric_params["ks_a"];
+      }
+      // set("grid.metric.params", params);
+
+      std::pair<real_t, real_t> dx0_V0;
+      if (metric_enum == Metric::Minkowski) {
+        if (dim == Dim::_1D) {
+          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_1D>>(resolution,
+                                                           extent_pairwise_,
+                                                           metric_params_short_);
+        } else if (dim == Dim::_2D) {
+          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_2D>>(resolution,
+                                                           extent_pairwise_,
+                                                           metric_params_short_);
+        } else {
+          dx0_V0 = get_dx0_V0<metric::Minkowski<Dim::_3D>>(resolution,
+                                                           extent_pairwise_,
+                                                           metric_params_short_);
+        }
+      } else if (metric_enum == Metric::Spherical) {
+        dx0_V0 = get_dx0_V0<metric::Spherical<Dim::_2D>>(resolution,
+                                                         extent_pairwise_,
+                                                         metric_params_short_);
+      } else if (metric_enum == Metric::QSpherical) {
+        dx0_V0 = get_dx0_V0<metric::QSpherical<Dim::_2D>>(resolution,
+                                                          extent_pairwise_,
+                                                          metric_params_short_);
+      } else if (metric_enum == Metric::Kerr_Schild) {
+        dx0_V0 = get_dx0_V0<metric::KerrSchild<Dim::_2D>>(resolution,
+                                                          extent_pairwise_,
+                                                          metric_params_short_);
+      } else if (metric_enum == Metric::Kerr_Schild_0) {
+        dx0_V0 = get_dx0_V0<metric::KerrSchild0<Dim::_2D>>(resolution,
+                                                           extent_pairwise_,
+                                                           metric_params_short_);
+      } else if (metric_enum == Metric::QKerr_Schild) {
+        dx0_V0 = get_dx0_V0<metric::QKerrSchild<Dim::_2D>>(resolution,
+                                                           extent_pairwise_,
+                                                           metric_params_short_);
+      }
+      auto [dx0, V0] = dx0_V0;
+      scale_dx0      = dx0;
+      scale_V0       = V0;
+    }
+
+    void Grid::setParams(SimulationParams* params) const {
+      params->set("simulation.domain.number", number_of_domains);
+      params->set("simulation.domain.decomposition", domain_decomposition);
+
+      params->set("grid.resolution", resolution);
+      params->set("grid.dim", dim);
+      params->set("grid.metric.metric", metric_enum);
+      params->set("grid.metric.coord", coord_enum);
+      for (const auto& [key, value] : metric_params) {
+        params->set("grid.metric." + key, value);
+      }
+      params->set("grid.metric.params", metric_params_short_);
+      params->set("grid.extent", extent_pairwise_);
+
+      params->set("scales.dx0", scale_dx0);
+      params->set("scales.V0", scale_V0);
+    }
+
+  } // namespace params
+} // namespace ntt
diff --git a/src/framework/parameters/grid.h b/src/framework/parameters/grid.h
new file mode 100644
index 000000000..bc73063d7
--- /dev/null
+++ b/src/framework/parameters/grid.h
@@ -0,0 +1,88 @@
+/**
+ * @file framework/parameters/grid.h
+ * @brief Auxiliary functions for reading in grid/box parameters
+ * @implements
+ *   - ntt::params::Boundaries
+ *   - ntt::params::GetBoundaryConditions -> (boundaries_t<FldsBC>, boundaries_t<PrtlBC>)
+ * @cpp:
+ *   - grid.cpp
+ * @namespaces:
+ *   - ntt::params::
+ */
+#ifndef FRAMEWORK_PARAMETERS_GRID_H
+#define FRAMEWORK_PARAMETERS_GRID_H
+
+#include "enums.h"
+#include "global.h"
+
+#include <toml11/toml.hpp>
+
+#include "framework/parameters/parameters.h"
+
+#include <map>
+#include <tuple>
+#include <vector>
+
+namespace ntt {
+  namespace params {
+
+    struct Boundaries {
+      const bool           needs_match_boundaries;
+      boundaries_t<real_t> match_ds_array;
+
+      const bool needs_absorb_boundaries;
+      real_t     absorb_ds;
+
+      const bool                  needs_atmosphere_boundaries;
+      real_t                      atmosphere_temperature;
+      real_t                      atmosphere_height;
+      real_t                      atmosphere_density;
+      real_t                      atmosphere_g;
+      real_t                      atmosphere_ds;
+      std::pair<spidx_t, spidx_t> atmosphere_species;
+
+      Boundaries(bool needs_match, bool needs_absorb, bool needs_atmosphere)
+        : needs_match_boundaries { needs_match }
+        , needs_absorb_boundaries { needs_absorb }
+        , needs_atmosphere_boundaries { needs_atmosphere } {}
+
+      void read(Dimension,
+                const Coord&,
+                const boundaries_t<real_t>&,
+                const toml::value&);
+      void setParams(SimulationParams*) const;
+    };
+
+    struct Grid {
+      unsigned int     number_of_domains;
+      std::vector<int> domain_decomposition;
+
+      std::vector<ncells_t> resolution;
+      Dimension             dim;
+
+      std::vector<std::vector<real_t>> extent;
+      boundaries_t<real_t>             extent_pairwise_;
+
+      Metric                        metric_enum = Metric::INVALID;
+      Coord                         coord_enum  = Coord::INVALID;
+      std::map<std::string, real_t> metric_params;
+      std::map<std::string, real_t> metric_params_short_;
+
+      real_t scale_dx0;
+      real_t scale_V0;
+
+      void read(const SimEngine&, const toml::value&);
+      void setParams(SimulationParams*) const;
+    };
+
+    auto GetBoundaryConditions(SimulationParams* params,
+                               const SimEngine&,
+                               Dimension,
+                               const Coord&,
+                               const toml::value&)
+      -> std::tuple<boundaries_t<FldsBC>, boundaries_t<PrtlBC>>;
+
+  } // namespace params
+} // namespace ntt
+
+#endif // FRAMEWORK_PARAMETERS_GRID_H
diff --git a/src/framework/parameters/output.cpp b/src/framework/parameters/output.cpp
new file mode 100644
index 000000000..3d06ff054
--- /dev/null
+++ b/src/framework/parameters/output.cpp
@@ -0,0 +1,203 @@
+#include "framework/parameters/output.h"
+
+#include "defaults.h"
+#include "global.h"
+
+#include "utils/error.h"
+#include "utils/log.h"
+#include <toml11/toml.hpp>
+
+namespace ntt {
+  namespace params {
+
+    void Output::read(Dimension dim, std::size_t nspec, const toml::value& toml_data) {
+      format = toml::find_or(toml_data, "output", "format", defaults::output::format);
+      global_interval      = toml::find_or(toml_data,
+                                      "output",
+                                      "interval",
+                                      defaults::output::interval);
+      global_interval_time = toml::find_or<simtime_t>(toml_data,
+                                                      "output",
+                                                      "interval_time",
+                                                      -1.0);
+      raise::ErrorIf(
+        not toml::find_or<bool>(toml_data, "output", "separate_files", true),
+        "separate_files=false is deprecated",
+        HERE);
+
+      for (const auto& category : { "fields", "particles", "spectra", "stats" }) {
+        const auto q_int            = toml::find_or<timestep_t>(toml_data,
+                                                     "output",
+                                                     category,
+                                                     "interval",
+                                                     0);
+        const auto q_int_time       = toml::find_or<simtime_t>(toml_data,
+                                                         "output",
+                                                         category,
+                                                         "interval_time",
+                                                         -1.0);
+        categories[category].enable = toml::find_or(toml_data,
+                                                    "output",
+                                                    category,
+                                                    "enable",
+                                                    true);
+        if ((q_int == 0) and (q_int_time == -1.0)) {
+          categories[category].interval      = global_interval;
+          categories[category].interval_time = global_interval_time;
+        } else {
+          categories[category].interval      = q_int;
+          categories[category].interval_time = q_int_time;
+        }
+      }
+
+      /* Fields --------------------------------------------------------------- */
+      const auto flds_out        = toml::find_or(toml_data,
+                                          "output",
+                                          "fields",
+                                          "quantities",
+                                          std::vector<std::string> {});
+      const auto custom_flds_out = toml::find_or(toml_data,
+                                                 "output",
+                                                 "fields",
+                                                 "custom",
+                                                 std::vector<std::string> {});
+      if (flds_out.size() == 0) {
+        raise::Warning("No fields output specified", HERE);
+      }
+      fields_quantities        = flds_out;
+      fields_custom_quantities = custom_flds_out;
+      fields_mom_smooth        = toml::find_or(toml_data,
+                                        "output",
+                                        "fields",
+                                        "mom_smooth",
+                                        defaults::output::mom_smooth);
+      try {
+        auto field_dwn_ = toml::find<std::vector<unsigned int>>(toml_data,
+                                                                "output",
+                                                                "fields",
+                                                                "downsampling");
+        for (auto i = 0u; i < field_dwn_.size(); ++i) {
+          fields_downsampling.push_back(field_dwn_[i]);
+        }
+      } catch (...) {
+        try {
+          auto field_dwn_ = toml::find<unsigned int>(toml_data,
+                                                     "output",
+                                                     "fields",
+                                                     "downsampling");
+          for (auto i = 0u; i < dim; ++i) {
+            fields_downsampling.push_back(field_dwn_);
+          }
+        } catch (...) {
+          for (auto i = 0u; i < dim; ++i) {
+            fields_downsampling.push_back(1u);
+          }
+        }
+      }
+      raise::ErrorIf(fields_downsampling.size() > 3,
+                     "invalid `output.fields.downsampling`",
+                     HERE);
+      if (fields_downsampling.size() > dim) {
+        fields_downsampling.erase(fields_downsampling.begin() + (std::size_t)(dim),
+                                  fields_downsampling.end());
+      }
+      for (const auto& dwn : fields_downsampling) {
+        raise::ErrorIf(dwn == 0, "downsampling factor must be nonzero", HERE);
+      }
+
+      /* Particles ------------------------------------------------------------ */
+      auto all_specs = std::vector<spidx_t> {};
+      for (auto i = 0u; i < nspec; ++i) {
+        all_specs.push_back(static_cast<spidx_t>(i + 1));
+      }
+      particles_species = toml::find_or(toml_data,
+                                        "output",
+                                        "particles",
+                                        "species",
+                                        all_specs);
+      particles_stride  = toml::find_or(toml_data,
+                                       "output",
+                                       "particles",
+                                       "stride",
+                                       defaults::output::prtl_stride);
+
+      /* Spectra -------------------------------------------------------------- */
+      spectra_e_min    = toml::find_or(toml_data,
+                                    "output",
+                                    "spectra",
+                                    "e_min",
+                                    defaults::output::spec_emin);
+      spectra_e_max    = toml::find_or(toml_data,
+                                    "output",
+                                    "spectra",
+                                    "e_max",
+                                    defaults::output::spec_emax);
+      spectra_log_bins = toml::find_or(toml_data,
+                                       "output",
+                                       "spectra",
+                                       "log_bins",
+                                       defaults::output::spec_log);
+      spectra_n_bins   = toml::find_or(toml_data,
+                                     "output",
+                                     "spectra",
+                                     "n_bins",
+                                     defaults::output::spec_nbins);
+
+      /* Stats ---------------------------------------------------------------- */
+      stats_quantities        = toml::find_or(toml_data,
+                                       "output",
+                                       "stats",
+                                       "quantities",
+                                       defaults::output::stats_quantities);
+      stats_custom_quantities = toml::find_or(toml_data,
+                                              "output",
+                                              "stats",
+                                              "custom",
+                                              std::vector<std::string> {});
+
+      /* Debug ---------------------------------------------------------------- */
+      debug_as_is = toml::find_or(toml_data, "output", "debug", "as_is", false);
+      debug_ghosts = toml::find_or(toml_data, "output", "debug", "ghosts", false);
+      if (debug_ghosts) {
+        for (const auto& dwn : fields_downsampling) {
+          raise::ErrorIf(
+            dwn != 1,
+            "full resolution required when outputting with ghost cells",
+            HERE);
+        }
+      }
+    }
+
+    void Output::setParams(SimulationParams* params) const {
+      params->set("output.format", format);
+      params->set("output.interval", global_interval);
+      params->set("output.interval_time", global_interval_time);
+      for (const auto& [category, cat_params] : categories) {
+        params->set("output." + category + ".enable", cat_params.enable);
+        params->set("output." + category + ".interval", cat_params.interval);
+        params->set("output." + category + ".interval_time",
+                    cat_params.interval_time);
+      }
+
+      params->set("output.fields.quantities", fields_quantities);
+      params->set("output.fields.custom", fields_custom_quantities);
+      params->set("output.fields.mom_smooth", fields_mom_smooth);
+      params->set("output.fields.downsampling", fields_downsampling);
+
+      params->set("output.particles.species", particles_species);
+      params->set("output.particles.stride", particles_stride);
+
+      params->set("output.spectra.e_min", spectra_e_min);
+      params->set("output.spectra.e_max", spectra_e_max);
+      params->set("output.spectra.log_bins", spectra_log_bins);
+      params->set("output.spectra.n_bins", spectra_n_bins);
+
+      params->set("output.stats.quantities", stats_quantities);
+      params->set("output.stats.custom", stats_custom_quantities);
+
+      params->set("output.debug.as_is", debug_as_is);
+      params->set("output.debug.ghosts", debug_ghosts);
+    }
+
+  } // namespace params
+} // namespace ntt
diff --git a/src/framework/parameters/output.h b/src/framework/parameters/output.h
new file mode 100644
index 000000000..08b3377d2
--- /dev/null
+++ b/src/framework/parameters/output.h
@@ -0,0 +1,68 @@
+/**
+ * @file framework/parameters/output.h
+ * @brief Auxiliary functions for reading in output parameters
+ * @implements
+ *   - ntt::params::Output
+ *   - ntt::params::OutputCategory
+ * @cpp:
+ *   - output.cpp
+ * @namespaces:
+ *   - ntt::params::
+ */
+#ifndef FRAMEWORK_PARAMETERS_OUTPUT_H
+#define FRAMEWORK_PARAMETERS_OUTPUT_H
+
+#include "global.h"
+
+#include <toml11/toml.hpp>
+
+#include "framework/parameters/parameters.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace ntt {
+  namespace params {
+
+    struct OutputCategory {
+      bool       enable;
+      timestep_t interval;
+      simtime_t  interval_time;
+    };
+
+    struct Output {
+      std::string format;
+
+      timestep_t global_interval;
+      simtime_t  global_interval_time;
+
+      std::map<std::string, OutputCategory> categories;
+
+      std::vector<std::string>  fields_quantities;
+      std::vector<std::string>  fields_custom_quantities;
+      unsigned short            fields_mom_smooth;
+      std::vector<unsigned int> fields_downsampling;
+
+      std::vector<spidx_t> particles_species;
+      npart_t              particles_stride;
+
+      real_t      spectra_e_min;
+      real_t      spectra_e_max;
+      bool        spectra_log_bins;
+      std::size_t spectra_n_bins;
+
+      std::vector<std::string> stats_quantities;
+      std::vector<std::string> stats_custom_quantities;
+
+      bool debug_as_is;
+      bool debug_ghosts;
+
+      void read(Dimension, std::size_t, const toml::value&);
+      void setParams(SimulationParams*) const;
+    };
+
+  } // namespace params
+} // namespace ntt
+
+#endif // FRAMEWORK_PARAMETERS_OUTPUT_H
diff --git a/src/framework/parameters/parameters.cpp b/src/framework/parameters/parameters.cpp
new file mode 100644
index 000000000..71f5d72e7
--- /dev/null
+++ b/src/framework/parameters/parameters.cpp
@@ -0,0 +1,345 @@
+#include "framework/parameters/parameters.h"
+
+#include "defaults.h"
+#include "enums.h"
+#include "global.h"
+
+#include "utils/error.h"
+#include "utils/formatting.h"
+#include "utils/numeric.h"
+#include <toml11/toml.hpp>
+
+#include "framework/containers/species.h"
+#include "framework/parameters/algorithms.h"
+#include "framework/parameters/extra.h"
+#include "framework/parameters/grid.h"
+#include "framework/parameters/output.h"
+#include "framework/parameters/particles.h"
+
+#if defined(MPI_ENABLED)
+  #include <mpi.h>
+#endif
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ntt {
+
+  /*
+   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+   * Parameters that must not be changed during the checkpoint restart
+   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+   */
+  void SimulationParams::setImmutableParams(const toml::value& toml_data) {
+    /* [simulation] --------------------------------------------------------- */
+    const auto engine_enum = SimEngine::pick(
+      fmt::toLower(toml::find<std::string>(toml_data, "simulation", "engine")).c_str());
+    set("simulation.engine", engine_enum);
+
+    /* grid and decomposition ------------------------------------------------ */
+    params::Grid grid_params {};
+    grid_params.read(engine_enum, toml_data);
+    grid_params.setParams(this);
+
+    /* [scales] ------------------------------------------------------------- */
+    const auto larmor0 = toml::find<real_t>(toml_data, "scales", "larmor0");
+    const auto skindepth0 = toml::find<real_t>(toml_data, "scales", "skindepth0");
+    raise::ErrorIf(larmor0 <= ZERO || skindepth0 <= ZERO,
+                   "larmor0 and skindepth0 must be positive",
+                   HERE);
+    set("scales.larmor0", larmor0);
+    set("scales.skindepth0", skindepth0);
+    set("scales.sigma0", SQR(skindepth0 / larmor0));
+    set("scales.B0", ONE / larmor0);
+    set("scales.omegaB0", ONE / larmor0);
+
+    /* [particles] ---------------------------------------------------------- */
+    const auto ppc0 = toml::find<real_t>(toml_data, "particles", "ppc0");
+    set("particles.ppc0", ppc0);
+    raise::ErrorIf(ppc0 <= 0.0, "ppc0 must be positive", HERE);
+    set("particles.use_weights",
+        toml::find_or(toml_data, "particles", "use_weights", false));
+
+    set("scales.n0", ppc0 / get<real_t>("scales.V0"));
+    set("scales.q0", get<real_t>("scales.V0") / (ppc0 * SQR(skindepth0)));
+
+    /* [particles.species] -------------------------------------------------- */
+    std::vector<ParticleSpecies> species;
+    const auto species_tab = toml::find_or<toml::array>(toml_data,
+                                                        "particles",
+                                                        "species",
+                                                        toml::array {});
+    set("particles.nspec", species_tab.size());
+
+    spidx_t idx = 1;
+    for (const auto& sp : species_tab) {
+      species.emplace_back(params::GetParticleSpecies(this, engine_enum, idx, sp));
+      idx += 1;
+    }
+    set("particles.species", species);
+  }
+
+  /*
+   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+   * Parameters that may be changed during the checkpoint restart
+   * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+   */
+  void SimulationParams::setMutableParams(const toml::value& toml_data) {
+    const auto engine_enum     = get<SimEngine>("simulation.engine");
+    const auto coord_enum      = get<Coord>("grid.metric.coord");
+    const auto dim             = get<Dimension>("grid.dim");
+    const auto extent_pairwise = get<boundaries_t<real_t>>("grid.extent");
+
+    /* [simulation] --------------------------------------------------------- */
+    set("simulation.name",
+        toml::find<std::string>(toml_data, "simulation", "name"));
+    set("simulation.runtime",
+        toml::find<simtime_t>(toml_data, "simulation", "runtime"));
+
+    /* [grid.boundaraies] --------------------------------------------------- */
+    const auto [flds_bc, prtl_bc] = params::GetBoundaryConditions(this,
+                                                                  engine_enum,
+                                                                  dim,
+                                                                  coord_enum,
+                                                                  toml_data);
+    set("grid.boundaries.fields", flds_bc);
+    set("grid.boundaries.particles", prtl_bc);
+
+    /* [particles] ---------------------------------------------------------- */
+    set("particles.clear_interval",
+        toml::find_or(toml_data, "particles", "clear_interval", defaults::clear_interval));
+    const auto species_tab               = toml::find_or<toml::array>(toml_data,
+                                                        "particles",
+                                                        "species",
+                                                        toml::array {});
+    std::vector<ParticleSpecies> species = get<std::vector<ParticleSpecies>>(
+      "particles.species");
+    raise::ErrorIf(species_tab.size() != species.size(),
+                   "number of species changed after restart",
+                   HERE);
+
+    std::vector<ParticleSpecies> new_species;
+
+    spidx_t idxM1 = 0;
+    for (const auto& sp : species_tab) {
+      const auto maxnpart_real    = toml::find<double>(sp, "maxnpart");
+      const auto maxnpart         = static_cast<npart_t>(maxnpart_real);
+      const auto particle_species = species[idxM1];
+      new_species.emplace_back(particle_species.index(),
+                               particle_species.label(),
+                               particle_species.mass(),
+                               particle_species.charge(),
+                               maxnpart,
+                               particle_species.pusher(),
+                               particle_species.use_tracking(),
+                               particle_species.radiative_drag_flags(),
+                               particle_species.emission_policy_flag(),
+                               particle_species.npld_r(),
+                               particle_species.npld_i());
+      idxM1++;
+    }
+    set("particles.species", new_species);
+
+    /* [output] ------------------------------------------------------------- */
+    params::Output output_params;
+    output_params.read(dim, get<std::size_t>("particles.nspec"), toml_data);
+    output_params.setParams(this);
+
+    /* [checkpoint] --------------------------------------------------------- */
+    set("checkpoint.interval",
+        toml::find_or(toml_data,
+                      "checkpoint",
+                      "interval",
+                      defaults::checkpoint::interval));
+    set("checkpoint.interval_time",
+        toml::find_or<simtime_t>(toml_data, "checkpoint", "interval_time", -1.0));
+    set("checkpoint.keep",
+        toml::find_or(toml_data, "checkpoint", "keep", defaults::checkpoint::keep));
+    auto walltime_str = toml::find_or(toml_data,
+                                      "checkpoint",
+                                      "walltime",
+                                      defaults::checkpoint::walltime);
+    if (walltime_str.empty()) {
+      walltime_str = defaults::checkpoint::walltime;
+    }
+    set("checkpoint.walltime", walltime_str);
+
+    const auto checkpoint_write_path = toml::find_or(
+      toml_data,
+      "checkpoint",
+      "write_path",
+      fmt::format(defaults::checkpoint::write_path.c_str(),
+                  get<std::string>("simulation.name").c_str()));
+    set("checkpoint.write_path", checkpoint_write_path);
+    set("checkpoint.read_path",
+        toml::find_or(toml_data, "checkpoint", "read_path", checkpoint_write_path));
+
+    /* [diagnostics] -------------------------------------------------------- */
+    set("diagnostics.interval",
+        toml::find_or(toml_data, "diagnostics", "interval", defaults::diag::interval));
+    set("diagnostics.blocking_timers",
+        toml::find_or(toml_data, "diagnostics", "blocking_timers", false));
+    set("diagnostics.colored_stdout",
+        toml::find_or(toml_data, "diagnostics", "colored_stdout", false));
+    set("diagnostics.log_level",
+        toml::find_or(toml_data, "diagnostics", "log_level", defaults::diag::log_level));
+
+    /* inferred variables --------------------------------------------------- */
+    params::Boundaries boundaries_params {
+      isPromised("grid.boundaries.match.ds"),
+      isPromised("grid.boundaries.absorb.ds"),
+      isPromised("grid.boundaries.atmosphere.temperature")
+    };
+    boundaries_params.read(dim, coord_enum, extent_pairwise, toml_data);
+    boundaries_params.setParams(this);
+
+    /* [algorithms] --------------------------------------------------------- */
+    params::Algorithms          alg_params {};
+    std::map<std::string, bool> alg_extra_flags = {
+      {  "gr",          engine_enum == SimEngine::GRPIC },
+      { "gca", isPromised("algorithms.gca.e_ovr_b_max") },
+    };
+    alg_params.read(get<real_t>("scales.dx0"), alg_extra_flags, toml_data);
+    alg_params.setParams(alg_extra_flags, this);
+
+    /* extra physics ------------------------------------------------------ */
+    params::Extra               extra_params {};
+    std::map<std::string, bool> extra_extra_flags = {
+      {     "synchrotron_drag",isPromised("radiation.drag.synchrotron.gamma_rad")                               },
+      {         "compton_drag",          isPromised("radiation.drag.compton.gamma_rad") },
+      { "synchrotron_emission",
+       isPromised("radiation.emission.synchrotron.photon_species")                     },
+      {     "compton_emission", isPromised("radiation.emission.compton.photon_species") }
+    };
+    extra_params.read(extra_extra_flags, toml_data, this);
+    extra_params.setParams(extra_extra_flags, this);
+
+    // @TODO: disabling stats for non-Cartesian
+    if (coord_enum != Coord::Cart) {
+      set("output.stats.enable", false);
+    }
+  }
+
+  void SimulationParams::setSetupParams(const toml::value& toml_data) {
+    /* [setup] -------------------------------------------------------------- */
+    const auto setup = toml::find_or(toml_data, "setup", toml::table {});
+    for (const auto& [key, val] : setup) {
+      if (val.is_boolean()) {
+        set("setup." + key, (bool)(val.as_boolean()));
+      } else if (val.is_integer()) {
+        set("setup." + key, (int)(val.as_integer()));
+      } else if (val.is_floating()) {
+        set("setup." + key, (real_t)(val.as_floating()));
+      } else if (val.is_string()) {
+        set("setup." + key, (std::string)(val.as_string()));
+      } else if (val.is_array()) {
+        const auto val_arr = val.as_array();
+        if (val_arr.size() == 0) {
+          continue;
+        } else {
+          if (val_arr[0].is_integer()) {
+            std::vector<int> vec;
+            for (const auto& v : val_arr) {
+              vec.push_back(v.as_integer());
+            }
+            set("setup." + key, vec);
+          } else if (val_arr[0].is_floating()) {
+            std::vector<real_t> vec;
+            for (const auto& v : val_arr) {
+              vec.push_back(v.as_floating());
+            }
+            set("setup." + key, vec);
+          } else if (val_arr[0].is_boolean()) {
+            std::vector<bool> vec;
+            for (const auto& v : val_arr) {
+              vec.push_back(v.as_boolean());
+            }
+            set("setup." + key, vec);
+          } else if (val_arr[0].is_string()) {
+            std::vector<std::string> vec;
+            for (const auto& v : val_arr) {
+              vec.push_back(v.as_string());
+            }
+            set("setup." + key, vec);
+          } else if (val_arr[0].is_array()) {
+            if (val_arr[0].as_array().size() == 0) {
+              raise::Error("empty inner arrays not allowed in [setup]", HERE);
+            } else if (val_arr[0][0].is_integer()) {
+              std::vector<std::vector<int>> vec;
+              for (const auto& v1 : val_arr) {
+                std::vector<int> inner_vec;
+                for (const auto& v2 : v1.as_array()) {
+                  inner_vec.push_back(v2.as_integer());
+                }
+                vec.push_back(inner_vec);
+              }
+              set("setup." + key, vec);
+            } else if (val_arr[0][0].is_floating()) {
+              std::vector<std::vector<real_t>> vec;
+              for (const auto& v1 : val_arr) {
+                std::vector<real_t> inner_vec;
+                for (const auto& v2 : v1.as_array()) {
+                  inner_vec.push_back(v2.as_floating());
+                }
+                vec.push_back(inner_vec);
+              }
+              set("setup." + key, vec);
+            } else if (val_arr[0][0].is_boolean()) {
+              std::vector<std::vector<bool>> vec;
+              for (const auto& v : val_arr) {
+                std::vector<bool> inner_vec;
+                for (const auto& v2 : v.as_array()) {
+                  inner_vec.push_back(v2.as_boolean());
+                }
+                vec.push_back(inner_vec);
+              }
+              set("setup." + key, vec);
+            } else if (val_arr[0][0].is_string()) {
+              std::vector<std::vector<std::string>> vec;
+              for (const auto& v : val_arr) {
+                std::vector<std::string> inner_vec;
+                for (const auto& v2 : v.as_array()) {
+                  inner_vec.push_back(v2.as_string());
+                }
+                vec.push_back(inner_vec);
+              }
+              set("setup." + key, vec);
+            } else if (val_arr[0][0].is_array()) {
+              raise::Error("up to 2D arrays allowed in [setup]", HERE);
+            }
+          } else {
+            raise::Error("invalid setup variable type", HERE);
+          }
+        }
+      }
+    }
+  }
+
+  void SimulationParams::setCheckpointParams(bool       is_resuming,
+                                             timestep_t start_step,
+                                             simtime_t  start_time) {
+    set("checkpoint.is_resuming", is_resuming);
+    set("checkpoint.start_step", start_step);
+    set("checkpoint.start_time", start_time);
+  }
+
+  void SimulationParams::checkPromises() const {
+    raise::ErrorIf(!promisesFulfilled(),
+                   "Have not defined all the necessary variables",
+                   HERE);
+  }
+
+  void SimulationParams::saveTOML(const std::string& path, simtime_t time) const {
+    CallOnce([&]() {
+      std::ofstream metadata;
+      metadata.open(path);
+      metadata << fmt::format("[metadata]\n  time = %f\n\n", time) << data()
+               << std::endl;
+      metadata.close();
+    });
+  }
+
+} // namespace ntt
diff --git a/src/framework/parameters.h b/src/framework/parameters/parameters.h
similarity index 88%
rename from src/framework/parameters.h
rename to src/framework/parameters/parameters.h
index 0af4fa405..175f30251 100644
--- a/src/framework/parameters.h
+++ b/src/framework/parameters/parameters.h
@@ -1,5 +1,5 @@
 /**
- * @file framework/parameters.h
+ * @file framework/parameters/parameters.h
  * @brief Structure for defining and holding initial simulation parameters
  * @implements
  *   - ntt::SimulationParams : ntt::Parameters
@@ -14,11 +14,11 @@
  * @note A proper metric is used to infer the minimum cell size/volume etc.
  */
 
-#ifndef FRAMEWORK_PARAMETERS_H
-#define FRAMEWORK_PARAMETERS_H
+#ifndef FRAMEWORK_PARAMETERS_PARAMETERS_H
+#define FRAMEWORK_PARAMETERS_PARAMETERS_H
 
 #include "utils/param_container.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
 #include <string>
 
@@ -62,4 +62,4 @@ namespace ntt {
 
 } // namespace ntt
 
-#endif // FRAMEWORK_PARAMETERS_H
+#endif // FRAMEWORK_PARAMETERS_PARAMETERS_H
diff --git a/src/framework/parameters/particles.cpp b/src/framework/parameters/particles.cpp
new file mode 100644
index 000000000..095727544
--- /dev/null
+++ b/src/framework/parameters/particles.cpp
@@ -0,0 +1,212 @@
+#include "framework/parameters/particles.h"
+
+#include "defaults.h"
+#include "enums.h"
+#include "global.h"
+
+#include "utils/error.h"
+#include "utils/formatting.h"
+#include <toml11/toml.hpp>
+
+#include "framework/containers/species.h"
+#include "framework/parameters/parameters.h"
+
+#include <string>
+
+namespace ntt {
+
+  namespace params {
+
+    /*
+     * Auxiliary functions
+     */
+    auto getRadiativeDragFlags(const std::string& radiative_drag_str)
+      -> RadiativeDragFlags {
+      if (fmt::toLower(radiative_drag_str) == "none") {
+        return RadiativeDrag::NONE;
+      } else {
+        // separate comas
+        RadiativeDragFlags flags = RadiativeDrag::NONE;
+        std::string        token;
+        std::istringstream tokenStream(radiative_drag_str);
+        while (std::getline(tokenStream, token, ',')) {
+          const auto token_lower = fmt::toLower(token);
+          if (token_lower == "synchrotron") {
+            flags |= RadiativeDrag::SYNCHROTRON;
+          } else if (token_lower == "compton") {
+            flags |= RadiativeDrag::COMPTON;
+          } else {
+            raise::Error(fmt::format("Invalid radiative_drag value: %s",
+                                     radiative_drag_str.c_str()),
+                         HERE);
+          }
+        }
+        return flags;
+      }
+    }
+
+    auto getPusherFlags(const std::string& particle_pusher_str)
+      -> ParticlePusherFlags {
+      if (fmt::toLower(particle_pusher_str) == "none") {
+        return ParticlePusher::NONE;
+      } else {
+        // separate comas
+        ParticlePusherFlags flags = ParticlePusher::NONE;
+        std::string         token;
+        std::istringstream  tokenStream(particle_pusher_str);
+        while (std::getline(tokenStream, token, ',')) {
+          const auto token_lower = fmt::toLower(token);
+          if (token_lower == "photon") {
+            flags |= ParticlePusher::PHOTON;
+          } else if (token_lower == "boris") {
+            flags |= ParticlePusher::BORIS;
+          } else if (token_lower == "vay") {
+            flags |= ParticlePusher::VAY;
+          } else if (token_lower == "gca") {
+            flags |= ParticlePusher::GCA;
+          } else {
+            raise::Error(fmt::format("Invalid pusher value: %s",
+                                     particle_pusher_str.c_str()),
+                         HERE);
+          }
+        }
+        if (flags & ParticlePusher::PHOTON and flags & ParticlePusher::GCA) {
+          raise::Error("Photon pusher cannot be used with GCA", HERE);
+        }
+        return flags;
+      }
+    }
+
+    auto getEmissionPolicyFlag(const std::string& emission_policy_str)
+      -> EmissionTypeFlag {
+      if (fmt::toLower(emission_policy_str) == "none") {
+        return EmissionType::NONE;
+      } else if (fmt::toLower(emission_policy_str) == "synchrotron") {
+        return EmissionType::SYNCHROTRON;
+      } else if (fmt::toLower(emission_policy_str) == "compton") {
+        return EmissionType::COMPTON;
+      } else {
+        raise::Error(fmt::format("Invalid emission_policy value: %s",
+                                 emission_policy_str.c_str()),
+                     HERE);
+        return EmissionType::NONE;
+      }
+    }
+
+    auto GetParticleSpecies(SimulationParams*  params,
+                            const SimEngine&   engine_enum,
+                            spidx_t            idx,
+                            const toml::value& sp) -> ParticleSpecies {
+      const auto label  = toml::find_or<std::string>(sp,
+                                                    "label",
+                                                    "s" + std::to_string(idx));
+      const auto mass   = toml::find<float>(sp, "mass");
+      const auto charge = toml::find<float>(sp, "charge");
+      raise::ErrorIf((charge != 0.0f) && (mass == 0.0f),
+                     "mass of the charged species must be non-zero",
+                     HERE);
+      const auto is_massless   = (mass == 0.0f) && (charge == 0.0f);
+      const auto def_pusher    = (is_massless ? defaults::ph_pusher
+                                              : defaults::em_pusher);
+      const auto maxnpart_real = toml::find<double>(sp, "maxnpart");
+      const auto maxnpart      = static_cast<npart_t>(maxnpart_real);
+      auto pusher_str = toml::find_or(sp, "pusher", std::string(def_pusher));
+      const auto npayloads_real = toml::find_or(sp,
+                                                "n_payloads_real",
+                                                static_cast<unsigned short>(0));
+      const auto use_tracking   = toml::find_or(sp, "tracking", false);
+      auto       npayloads_int  = toml::find_or(sp,
+                                         "n_payloads_int",
+                                         static_cast<unsigned short>(0));
+      if (use_tracking) {
+#if !defined(MPI_ENABLED)
+        npayloads_int += 1;
+#else
+        npayloads_int += 2;
+#endif
+      }
+      auto radiative_drag_str = toml::find_or(sp,
+                                              "radiative_drag",
+                                              std::string("default"));
+
+      const auto radiative_drag_defaulted = (fmt::toLower(radiative_drag_str) ==
+                                             "default");
+      if (radiative_drag_defaulted) {
+        radiative_drag_str = "none";
+      }
+
+      const auto emission_policy_str = toml::find_or(sp,
+                                                     "emission",
+                                                     std::string("none"));
+      raise::ErrorIf((fmt::toLower(radiative_drag_str) != "none") && is_massless,
+                     "radiative drag is only applicable to massive particles",
+                     HERE);
+      raise::ErrorIf((fmt::toLower(pusher_str) == "photon") && !is_massless,
+                     "photon pusher is only applicable to massless particles",
+                     HERE);
+
+      auto particle_pusher_flags = getPusherFlags(pusher_str);
+      auto radiative_drag_flags  = getRadiativeDragFlags(radiative_drag_str);
+      auto emission_policy_flag  = getEmissionPolicyFlag(emission_policy_str);
+
+      raise::ErrorIf((emission_policy_flag == EmissionType::SYNCHROTRON or
+                      emission_policy_flag == EmissionType::COMPTON) and
+                       is_massless,
+                     "Radiative emission policies are only applicable to "
+                     "massive particles",
+                     HERE);
+
+      if (radiative_drag_defaulted) {
+        if (emission_policy_flag == EmissionType::SYNCHROTRON) {
+          radiative_drag_flags |= RadiativeDrag::SYNCHROTRON;
+        } else if (emission_policy_flag == EmissionType::COMPTON) {
+          radiative_drag_flags |= RadiativeDrag::COMPTON;
+        }
+      }
+
+      if (radiative_drag_flags & RadiativeDrag::SYNCHROTRON) {
+        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
+                       "Synchrotron radiative drag is only supported for SRPIC",
+                       HERE);
+        params->promiseToDefine("radiation.drag.synchrotron.gamma_rad");
+      }
+      if (radiative_drag_flags & RadiativeDrag::COMPTON) {
+        raise::ErrorIf(
+          engine_enum != SimEngine::SRPIC,
+          "Inverse Compton radiative drag is only supported for SRPIC",
+          HERE);
+        params->promiseToDefine("radiation.drag.compton.gamma_rad");
+      }
+      if (particle_pusher_flags & ParticlePusher::GCA) {
+        raise::ErrorIf(engine_enum != SimEngine::SRPIC,
+                       "GCA pushers are only supported for SRPIC",
+                       HERE);
+        params->promiseToDefine("algorithms.gca.e_ovr_b_max");
+        params->promiseToDefine("algorithms.gca.larmor_max");
+      }
+
+      if (emission_policy_flag == EmissionType::SYNCHROTRON) {
+        params->promiseToDefine(
+          "radiation.emission.synchrotron.photon_species");
+        params->promiseToDefine("radiation.drag.synchrotron.gamma_rad");
+      } else if (emission_policy_flag == EmissionType::COMPTON) {
+        params->promiseToDefine("radiation.emission.compton.photon_species");
+        params->promiseToDefine("radiation.drag.compton.gamma_rad");
+      }
+
+      return ParticleSpecies(idx,
+                             label,
+                             mass,
+                             charge,
+                             maxnpart,
+                             particle_pusher_flags,
+                             use_tracking,
+                             radiative_drag_flags,
+                             emission_policy_flag,
+                             npayloads_real,
+                             npayloads_int);
+    }
+
+  } // namespace params
+
+} // namespace ntt
diff --git a/src/framework/parameters/particles.h b/src/framework/parameters/particles.h
new file mode 100644
index 000000000..8f5880e5e
--- /dev/null
+++ b/src/framework/parameters/particles.h
@@ -0,0 +1,34 @@
+/**
+ * @file framework/parameters/particles.h
+ * @brief Auxiliary functions for reading in particle species parameters
+ * @implements
+ *   - ntt::params::GetParticleSpecies -> ParticleSpecies
+ * @cpp:
+ *   - particles.cpp
+ * @namespaces:
+ *   - ntt::params::
+ */
+#ifndef FRAMEWORK_PARAMETERS_PARTICLES_H
+#define FRAMEWORK_PARAMETERS_PARTICLES_H
+
+#include "enums.h"
+
+#include <toml11/toml.hpp>
+
+#include "framework/containers/species.h"
+#include "framework/parameters/parameters.h"
+
+namespace ntt {
+
+  namespace params {
+
+    auto GetParticleSpecies(SimulationParams*,
+                            const SimEngine&,
+                            spidx_t,
+                            const toml::value&) -> ParticleSpecies;
+
+  } // namespace params
+
+} // namespace ntt
+
+#endif
diff --git a/src/framework/simulation.cpp b/src/framework/simulation.cpp
index 20dc39486..db133c0f8 100644
--- a/src/framework/simulation.cpp
+++ b/src/framework/simulation.cpp
@@ -9,7 +9,7 @@
 #include "utils/formatting.h"
 #include "utils/log.h"
 #include "utils/plog.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
 #include <filesystem>
 #include <string>
diff --git a/src/framework/simulation.h b/src/framework/simulation.h
index 33750030f..745c76db4 100644
--- a/src/framework/simulation.h
+++ b/src/framework/simulation.h
@@ -16,11 +16,11 @@
 
 #include "enums.h"
 
-#include "arch/traits.h"
 #include "utils/error.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
-#include "framework/parameters.h"
+#include "engines/traits.h"
+#include "framework/parameters/parameters.h"
 
 namespace ntt {
 
@@ -36,12 +36,9 @@ namespace ntt {
     ~Simulation();
 
     template <template <class> class E, template <Dimension> class M, Dimension D>
+      requires traits::engine::HasRun<E<M<D>>>
     inline void run() {
       using engine_t = E<M<D>>;
-      static_assert(engine_t::is_engine,
-                    "template arg for Simulation::run has to be an engine");
-      static_assert(traits::has_method<traits::run_t, engine_t>::value,
-                    "Engine must contain a ::run() method");
       try {
         engine_t engine { m_params };
         engine.run();
diff --git a/src/framework/specialization_registry.h b/src/framework/specialization_registry.h
index e2628c420..3b82e3d03 100644
--- a/src/framework/specialization_registry.h
+++ b/src/framework/specialization_registry.h
@@ -1,12 +1,8 @@
-// SPDX-License-Identifier: BSD-3-Clause
-
 #ifndef FRAMEWORK_SPECIALIZATION_REGISTRY_H
 #define FRAMEWORK_SPECIALIZATION_REGISTRY_H
 
 #include "enums.h"
 
-#include "arch/traits.h"
-
 #include "metrics/kerr_schild.h"
 #include "metrics/kerr_schild_0.h"
 #include "metrics/minkowski.h"
diff --git a/src/framework/tests/parameters.cpp b/src/framework/tests/parameters.cpp
index 78a3294b1..3b59a3324 100644
--- a/src/framework/tests/parameters.cpp
+++ b/src/framework/tests/parameters.cpp
@@ -1,11 +1,11 @@
-#include "framework/parameters.h"
+#include "framework/parameters/parameters.h"
 
 #include "defaults.h"
 #include "enums.h"
 
 #include "utils/comparators.h"
 #include "utils/error.h"
-#include "utils/toml.h"
+#include <toml11/toml.hpp>
 
 #include "framework/containers/species.h"
 
@@ -125,6 +125,21 @@ const auto sph_2d = u8R"(
   larmor0 = 0.01
   skindepth0 = 0.01
 
+[radiation]
+  [radiation.drag]
+    [radiation.drag.synchrotron]
+      gamma_rad = 50.0
+
+    [radiation.drag.compton]
+      gamma_rad = 20.0
+
+  [radiation.emission]
+    [radiation.emission.synchrotron]
+      gamma_qed = 100.0
+      photon_energy_min = 0.01
+      photon_weight = 10.0
+      photon_species = 3
+
 [algorithms]
   current_filters = 8
 
@@ -135,9 +150,6 @@ const auto sph_2d = u8R"(
     e_ovr_b_max = 0.95
     larmor_max = 0.025
 
-  [algorithms.synchrotron]
-    gamma_rad = 50.0
-
 [particles]
   ppc0 = 25.0
   use_weights = true
@@ -151,7 +163,8 @@ const auto sph_2d = u8R"(
     maxnpart = 1e2
     pusher = "boris,gca"
     n_payloads_real = 3
-    cooling = "synchrotron"
+    radiative_drag = "synchrotron,compton"
+    emission = "synchrotron"
 
   [[particles.species]]
     label = "e+"
@@ -159,7 +172,7 @@ const auto sph_2d = u8R"(
     charge = 1.0
     maxnpart = 1e2
     pusher = "boris,gca"
-    cooling = "synchrotron"
+    radiative_drag = "synchrotron"
     n_payloads_int = 2
 
   [[particles.species]]
@@ -254,135 +267,135 @@ auto main(int argc, char* argv[]) -> int {
   try {
     using namespace ntt;
 
-    {
-      auto params_mink_1d = SimulationParams();
-      params_mink_1d.setImmutableParams(mink_1d);
-      params_mink_1d.setMutableParams(mink_1d);
-      params_mink_1d.setSetupParams(mink_1d);
-      params_mink_1d.checkPromises();
-
-      assert_equal<Metric>(params_mink_1d.get<Metric>("grid.metric.metric"),
-                           Metric::Minkowski,
-                           "grid.metric.metric");
-      //  engine
-      assert_equal<SimEngine>(
-        params_mink_1d.get<SimEngine>("simulation.engine"),
-        SimEngine::SRPIC,
-        "simulation.engine");
-
-      assert_equal(params_mink_1d.get<real_t>("scales.dx0"),
-                   (real_t)0.0078125,
-                   "scales.dx0");
-      assert_equal(params_mink_1d.get<real_t>("scales.V0"),
-                   (real_t)0.0078125,
-                   "scales.V0");
-      boundaries_t<FldsBC> fbc = {
-        { FldsBC::MATCH, FldsBC::MATCH }
-      };
-      assert_equal<FldsBC>(
-        params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields")[0].first,
-        fbc[0].first,
-        "grid.boundaries.fields[0].first");
-      assert_equal<FldsBC>(
-        params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields")[0].second,
-        fbc[0].second,
-        "grid.boundaries.fields[0].second");
-      assert_equal(
-        params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields").size(),
-        fbc.size(),
-        "grid.boundaries.fields.size()");
-      assert_equal(
-        params_mink_1d.get<boundaries_t<real_t>>("grid.boundaries.match.ds")[0].first,
-        (real_t)0.025,
-        "grid.boundaries.match.ds[0].first");
-      assert_equal(
-        params_mink_1d.get<boundaries_t<real_t>>("grid.boundaries.match.ds")[0].second,
-        (real_t)0.1,
-        "grid.boundaries.match.ds[0].first");
-
-      const auto species = params_mink_1d.get<std::vector<ParticleSpecies>>(
-        "particles.species");
-      assert_equal<std::string>(species[0].label(), "e-", "species[0].label");
-      assert_equal(species[0].mass(), 1.0f, "species[0].mass");
-      assert_equal(species[0].charge(), -1.0f, "species[0].charge");
-      assert_equal<std::size_t>(species[0].maxnpart(), 100, "species[0].maxnpart");
-      assert_equal<PrtlPusher>(species[0].pusher(),
-                               PrtlPusher::BORIS,
-                               "species[0].pusher");
-      assert_equal<unsigned short>(species[0].npld_r(), 3, "species[0].npld_r");
-      assert_equal<unsigned short>(species[0].npld_i(), 1, "species[0].npld_i");
-      assert_equal<bool>(species[0].use_tracking(), true, "species[0].tracking");
-
-      assert_equal<std::string>(species[1].label(), "p+", "species[1].label");
-      assert_equal(species[1].mass(), 1.0f, "species[1].mass");
-      assert_equal(species[1].charge(), 200.0f, "species[1].charge");
-      assert_equal<std::size_t>(species[1].maxnpart(), 100, "species[1].maxnpart");
-      assert_equal<PrtlPusher>(species[1].pusher(),
-                               PrtlPusher::VAY,
-                               "species[1].pusher");
-      assert_equal<unsigned short>(species[1].npld_r(), 0, "species[1].npld_r");
-
-      assert_equal<real_t>(params_mink_1d.get<real_t>("setup.myfloat"),
-                           (real_t)(1e-2),
-                           "setup.myfloat");
-      assert_equal<int>(params_mink_1d.get<int>("setup.myint"),
-                        (int)(123),
-                        "setup.myint");
-      assert_equal<bool>(params_mink_1d.get<bool>("setup.mybool"),
-                         true,
-                         "setup.mybool");
-      const auto myarr = params_mink_1d.get<std::vector<real_t>>("setup.myarr");
-      assert_equal<real_t>(myarr[0], 1.0, "setup.myarr[0]");
-      assert_equal<real_t>(myarr[1], 2.0, "setup.myarr[1]");
-      assert_equal<real_t>(myarr[2], 3.0, "setup.myarr[2]");
-      assert_equal<std::string>(params_mink_1d.get<std::string>("setup.mystr"),
-                                "hi",
-                                "setup.mystr");
-
-      const auto output_stride = params_mink_1d.get<std::vector<unsigned int>>(
-        "output.fields.downsampling");
-      assert_equal<std::size_t>(output_stride.size(),
-                                1,
-                                "output.fields.downsampling.size()");
-      assert_equal<unsigned int>(output_stride[0], 4, "output.fields.downsampling[0]");
-
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_x"),
-        (real_t)(1.0),
-        "algorithms.fieldsolver.delta_x");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_y"),
-        (real_t)(2.0),
-        "algorithms.fieldsolver.delta_y");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_z"),
-        (real_t)(3.0),
-        "algorithms.fieldsolver.delta_z");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_xy"),
-        (real_t)(4.0),
-        "algorithms.fieldsolver.beta_xy");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_yx"),
-        (real_t)(5.0),
-        "algorithms.fieldsolver.beta_yx");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_xz"),
-        (real_t)(6.0),
-        "algorithms.fieldsolver.beta_xz");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_zx"),
-        (real_t)(7.0),
-        "algorithms.fieldsolver.beta_zx");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_yz"),
-        (real_t)(8.0),
-        "algorithms.fieldsolver.beta_yz");
-      assert_equal<real_t>(
-        params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_zy"),
-        (real_t)(9.0),
-        "algorithms.fieldsolver.beta_zy");
-    }
+    // {
+    //   auto params_mink_1d = SimulationParams();
+    //   params_mink_1d.setImmutableParams(mink_1d);
+    //   params_mink_1d.setMutableParams(mink_1d);
+    //   params_mink_1d.setSetupParams(mink_1d);
+    //   params_mink_1d.checkPromises();
+    //
+    //   assert_equal<Metric>(params_mink_1d.get<Metric>("grid.metric.metric"),
+    //                        Metric::Minkowski,
+    //                        "grid.metric.metric");
+    //   //  engine
+    //   assert_equal<SimEngine>(
+    //     params_mink_1d.get<SimEngine>("simulation.engine"),
+    //     SimEngine::SRPIC,
+    //     "simulation.engine");
+    //
+    //   assert_equal(params_mink_1d.get<real_t>("scales.dx0"),
+    //                (real_t)0.0078125,
+    //                "scales.dx0");
+    //   assert_equal(params_mink_1d.get<real_t>("scales.V0"),
+    //                (real_t)0.0078125,
+    //                "scales.V0");
+    //   boundaries_t<FldsBC> fbc = {
+    //     { FldsBC::MATCH, FldsBC::MATCH }
+    //   };
+    //   assert_equal<FldsBC>(
+    //     params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields")[0].first,
+    //     fbc[0].first,
+    //     "grid.boundaries.fields[0].first");
+    //   assert_equal<FldsBC>(
+    //     params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields")[0].second,
+    //     fbc[0].second,
+    //     "grid.boundaries.fields[0].second");
+    //   assert_equal(
+    //     params_mink_1d.get<boundaries_t<FldsBC>>("grid.boundaries.fields").size(),
+    //     fbc.size(),
+    //     "grid.boundaries.fields.size()");
+    //   assert_equal(
+    //     params_mink_1d.get<boundaries_t<real_t>>("grid.boundaries.match.ds")[0].first,
+    //     (real_t)0.025,
+    //     "grid.boundaries.match.ds[0].first");
+    //   assert_equal(
+    //     params_mink_1d.get<boundaries_t<real_t>>("grid.boundaries.match.ds")[0].second,
+    //     (real_t)0.1,
+    //     "grid.boundaries.match.ds[0].first");
+    //
+    //   const auto species = params_mink_1d.get<std::vector<ParticleSpecies>>(
+    //     "particles.species");
+    //   assert_equal<std::string>(species[0].label(), "e-", "species[0].label");
+    //   assert_equal(species[0].mass(), 1.0f, "species[0].mass");
+    //   assert_equal(species[0].charge(), -1.0f, "species[0].charge");
+    //   assert_equal<std::size_t>(species[0].maxnpart(), 100, "species[0].maxnpart");
+    //   assert_equal<ParticlePusherFlags>(species[0].pusher(),
+    //                                     ParticlePusher::BORIS,
+    //                                     "species[0].pusher");
+    //   assert_equal<unsigned short>(species[0].npld_r(), 3, "species[0].npld_r");
+    //   assert_equal<unsigned short>(species[0].npld_i(), 1, "species[0].npld_i");
+    //   assert_equal<bool>(species[0].use_tracking(), true, "species[0].tracking");
+    //
+    //   assert_equal<std::string>(species[1].label(), "p+", "species[1].label");
+    //   assert_equal(species[1].mass(), 1.0f, "species[1].mass");
+    //   assert_equal(species[1].charge(), 200.0f, "species[1].charge");
+    //   assert_equal<std::size_t>(species[1].maxnpart(), 100, "species[1].maxnpart");
+    //   assert_equal<ParticlePusherFlags>(species[1].pusher(),
+    //                                     ParticlePusher::VAY,
+    //                                     "species[1].pusher");
+    //   assert_equal<unsigned short>(species[1].npld_r(), 0, "species[1].npld_r");
+    //
+    //   assert_equal<real_t>(params_mink_1d.get<real_t>("setup.myfloat"),
+    //                        (real_t)(1e-2),
+    //                        "setup.myfloat");
+    //   assert_equal<int>(params_mink_1d.get<int>("setup.myint"),
+    //                     (int)(123),
+    //                     "setup.myint");
+    //   assert_equal<bool>(params_mink_1d.get<bool>("setup.mybool"),
+    //                      true,
+    //                      "setup.mybool");
+    //   const auto myarr = params_mink_1d.get<std::vector<real_t>>("setup.myarr");
+    //   assert_equal<real_t>(myarr[0], 1.0, "setup.myarr[0]");
+    //   assert_equal<real_t>(myarr[1], 2.0, "setup.myarr[1]");
+    //   assert_equal<real_t>(myarr[2], 3.0, "setup.myarr[2]");
+    //   assert_equal<std::string>(params_mink_1d.get<std::string>("setup.mystr"),
+    //                             "hi",
+    //                             "setup.mystr");
+    //
+    //   const auto output_stride = params_mink_1d.get<std::vector<unsigned int>>(
+    //     "output.fields.downsampling");
+    //   assert_equal<std::size_t>(output_stride.size(),
+    //                             1,
+    //                             "output.fields.downsampling.size()");
+    //   assert_equal<unsigned int>(output_stride[0], 4, "output.fields.downsampling[0]");
+    //
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_x"),
+    //     (real_t)(1.0),
+    //     "algorithms.fieldsolver.delta_x");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_y"),
+    //     (real_t)(2.0),
+    //     "algorithms.fieldsolver.delta_y");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.delta_z"),
+    //     (real_t)(3.0),
+    //     "algorithms.fieldsolver.delta_z");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_xy"),
+    //     (real_t)(4.0),
+    //     "algorithms.fieldsolver.beta_xy");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_yx"),
+    //     (real_t)(5.0),
+    //     "algorithms.fieldsolver.beta_yx");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_xz"),
+    //     (real_t)(6.0),
+    //     "algorithms.fieldsolver.beta_xz");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_zx"),
+    //     (real_t)(7.0),
+    //     "algorithms.fieldsolver.beta_zx");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_yz"),
+    //     (real_t)(8.0),
+    //     "algorithms.fieldsolver.beta_yz");
+    //   assert_equal<real_t>(
+    //     params_mink_1d.get<real_t>("algorithms.fieldsolver.beta_zy"),
+    //     (real_t)(9.0),
+    //     "algorithms.fieldsolver.beta_zy");
+    // }
 
     {
       auto params_sph_2d = SimulationParams();
@@ -454,9 +467,31 @@ auto main(int argc, char* argv[]) -> int {
                    "algorithms.gca.larmor_max");
 
       assert_equal(
-        params_sph_2d.get<real_t>("algorithms.synchrotron.gamma_rad"),
+        params_sph_2d.get<real_t>("radiation.drag.synchrotron.gamma_rad"),
         (real_t)50.0,
-        "algorithms.synchrotron.gamma_rad");
+        "radiation.drag.synchrotron.gamma_rad");
+
+      assert_equal(
+        params_sph_2d.get<real_t>("radiation.drag.compton.gamma_rad"),
+        (real_t)20.0,
+        "radiation.drag.compton.gamma_rad");
+
+      assert_equal(params_sph_2d.get<real_t>(
+                     "radiation.emission.synchrotron.photon_energy_min"),
+                   (real_t)0.01,
+                   "radiation.emission.synchrotron.photon_energy_min");
+      assert_equal(
+        params_sph_2d.get<real_t>("radiation.emission.synchrotron.gamma_qed"),
+        (real_t)100.0,
+        "radiation.emission.synchrotron.gamma_qed");
+      assert_equal(params_sph_2d.get<real_t>(
+                     "radiation.emission.synchrotron.photon_weight"),
+                   (real_t)10.0,
+                   "radiation.emission.synchrotron.photon_weight");
+      assert_equal<spidx_t>(params_sph_2d.get<spidx_t>(
+                              "radiation.emission.synchrotron.photon_species"),
+                            3,
+                            "radiation.emission.synchrotron.photon_species");
 
       const auto species = params_sph_2d.get<std::vector<ParticleSpecies>>(
         "particles.species");
@@ -464,27 +499,30 @@ auto main(int argc, char* argv[]) -> int {
       assert_equal(species[0].mass(), 1.0f, "species[0].mass");
       assert_equal(species[0].charge(), -1.0f, "species[0].charge");
       assert_equal<std::size_t>(species[0].maxnpart(), 100, "species[0].maxnpart");
-      assert_equal<PrtlPusher>(species[0].pusher(),
-                               PrtlPusher::BORIS,
-                               "species[0].pusher");
-      assert_equal<PrtlPusher>(species[0].use_gca(), true, "species[0].use_gca");
+      assert_equal<ParticlePusherFlags>(species[0].pusher(),
+                                        ParticlePusher::BORIS | ParticlePusher::GCA,
+                                        "species[0].pusher");
       assert_equal<unsigned short>(species[0].npld_r(), 3, "species[0].npld_r");
-      assert_equal<Cooling>(species[0].cooling(),
-                            Cooling::SYNCHROTRON,
-                            "species[0].cooling");
+      assert_equal<RadiativeDragFlags>(species[0].radiative_drag_flags(),
+                                       RadiativeDrag::SYNCHROTRON |
+                                         RadiativeDrag::COMPTON,
+                                       "species[0].radiative_drag_flags");
+
+      assert_equal<EmissionTypeFlag>(species[0].emission_policy_flag(),
+                                     EmissionType::SYNCHROTRON,
+                                     "species[0].emission_policy_flag");
 
       assert_equal<std::string>(species[1].label(), "e+", "species[1].label");
       assert_equal(species[1].mass(), 1.0f, "species[1].mass");
       assert_equal(species[1].charge(), 1.0f, "species[1].charge");
       assert_equal<std::size_t>(species[1].maxnpart(), 100, "species[1].maxnpart");
-      assert_equal<PrtlPusher>(species[1].pusher(),
-                               PrtlPusher::BORIS,
-                               "species[1].pusher");
-      assert_equal<PrtlPusher>(species[1].use_gca(), true, "species[1].use_gca");
+      assert_equal<ParticlePusherFlags>(species[1].pusher(),
+                                        ParticlePusher::BORIS | ParticlePusher::GCA,
+                                        "species[1].pusher");
       assert_equal<unsigned short>(species[1].npld_r(), 0, "species[1].npld_r");
-      assert_equal<Cooling>(species[1].cooling(),
-                            Cooling::SYNCHROTRON,
-                            "species[1].cooling");
+      assert_equal<RadiativeDragFlags>(species[1].radiative_drag_flags(),
+                                       RadiativeDrag::SYNCHROTRON,
+                                       "species[1].radiative_drag_flags");
       assert_equal<unsigned short>(species[1].npld_i(), 2, "species[1].npld_i");
       assert_equal<bool>(species[1].use_tracking(), false, "species[1].tracking");
 
@@ -492,9 +530,9 @@ auto main(int argc, char* argv[]) -> int {
       assert_equal(species[2].mass(), 0.0f, "species[2].mass");
       assert_equal(species[2].charge(), 0.0f, "species[2].charge");
       assert_equal<std::size_t>(species[2].maxnpart(), 100, "species[2].maxnpart");
-      assert_equal<PrtlPusher>(species[2].pusher(),
-                               PrtlPusher::PHOTON,
-                               "species[2].pusher");
+      assert_equal<ParticlePusherFlags>(species[2].pusher(),
+                                        ParticlePusher::PHOTON,
+                                        "species[2].pusher");
       assert_equal<unsigned short>(species[2].npld_r(), 0, "species[2].npld_r");
     }
 
@@ -601,18 +639,18 @@ auto main(int argc, char* argv[]) -> int {
       assert_equal(species[0].mass(), 1.0f, "species[0].mass");
       assert_equal(species[0].charge(), -1.0f, "species[0].charge");
       assert_equal<std::size_t>(species[0].maxnpart(), 100, "species[0].maxnpart");
-      assert_equal<PrtlPusher>(species[0].pusher(),
-                               PrtlPusher::BORIS,
-                               "species[0].pusher");
+      assert_equal<ParticlePusherFlags>(species[0].pusher(),
+                                        ParticlePusher::BORIS,
+                                        "species[0].pusher");
       assert_equal<unsigned short>(species[0].npld_r(), 0, "species[0].npld_r");
 
       assert_equal<std::string>(species[1].label(), "e+", "species[1].label");
       assert_equal(species[1].mass(), 1.0f, "species[1].mass");
       assert_equal(species[1].charge(), 1.0f, "species[1].charge");
       assert_equal<std::size_t>(species[1].maxnpart(), 100, "species[1].maxnpart");
-      assert_equal<PrtlPusher>(species[1].pusher(),
-                               PrtlPusher::BORIS,
-                               "species[1].pusher");
+      assert_equal<ParticlePusherFlags>(species[1].pusher(),
+                                        ParticlePusher::BORIS,
+                                        "species[1].pusher");
       assert_equal<unsigned short>(species[1].npld_r(), 0, "species[1].npld_r");
     }
 
diff --git a/src/framework/tests/particles.cpp b/src/framework/tests/particles.cpp
index ab3aa0e04..cce6af28b 100644
--- a/src/framework/tests/particles.cpp
+++ b/src/framework/tests/particles.cpp
@@ -9,16 +9,18 @@
 #include <string>
 
 template <Dimension D, ntt::Coord::type C>
-void testParticles(int                    index,
-                   const std::string&     label,
-                   float                  m,
-                   float                  ch,
-                   std::size_t            maxnpart,
-                   const ntt::PrtlPusher& pusher,
-                   bool                   use_tracking,
-                   const ntt::Cooling&    cooling,
-                   unsigned short         npld_r = 0,
-                   unsigned short         npld_i = 0) {
+void testParticles(
+  int                      index,
+  const std::string&       label,
+  float                    m,
+  float                    ch,
+  std::size_t              maxnpart,
+  ntt::ParticlePusherFlags pusher,
+  bool                     use_tracking,
+  ntt::RadiativeDragFlags  radiative_drag_flags,
+  ntt::EmissionTypeFlag    emission_policy_flag = ntt::EmissionType::NONE,
+  unsigned short           npld_r               = 0,
+  unsigned short           npld_i               = 0) {
   using namespace ntt;
   auto p = Particles<D, C>(index,
                            label,
@@ -27,8 +29,8 @@ void testParticles(int                    index,
                            maxnpart,
                            pusher,
                            use_tracking,
-                           false,
-                           cooling,
+                           radiative_drag_flags,
+                           emission_policy_flag,
                            npld_r,
                            npld_i);
   raise::ErrorIf(p.index() != index, "Index mismatch", HERE);
@@ -37,7 +39,12 @@ void testParticles(int                    index,
   raise::ErrorIf(p.charge() != ch, "Charge mismatch", HERE);
   raise::ErrorIf(p.maxnpart() != maxnpart, "Max number of particles mismatch", HERE);
   raise::ErrorIf(p.pusher() != pusher, "Pusher mismatch", HERE);
-  raise::ErrorIf(p.cooling() != cooling, "Cooling mismatch", HERE);
+  raise::ErrorIf(p.radiative_drag_flags() != radiative_drag_flags,
+                 "Radiative drag mismatch",
+                 HERE);
+  raise::ErrorIf(p.emission_policy_flag() != emission_policy_flag,
+                 "Emission policy mismatch",
+                 HERE);
   raise::ErrorIf(p.npart() != 0, "Number of particles mismatch", HERE);
 
   raise::ErrorIf(p.i1.extent(0) != maxnpart, "i1 incorrectly allocated", HERE);
@@ -115,17 +122,19 @@ auto main(int argc, char** argv) -> int {
                                          1.0,
                                          -1.0,
                                          100,
-                                         PrtlPusher::BORIS,
+                                         ParticlePusher::BORIS,
                                          false,
-                                         Cooling::SYNCHROTRON);
+                                         RadiativeDrag::SYNCHROTRON);
     testParticles<Dim::_2D, Coord::Cart>(2,
                                          "p+",
                                          100.0,
                                          -1.0,
                                          1000,
-                                         PrtlPusher::VAY,
+                                         ParticlePusher::VAY,
                                          true,
-                                         Cooling::SYNCHROTRON,
+                                         RadiativeDrag::SYNCHROTRON |
+                                           RadiativeDrag::COMPTON,
+                                         EmissionType::SYNCHROTRON,
                                          2,
                                          1);
     testParticles<Dim::_3D, Coord::Cart>(3,
@@ -133,18 +142,20 @@ auto main(int argc, char** argv) -> int {
                                          0.0,
                                          0.0,
                                          100,
-                                         PrtlPusher::PHOTON,
+                                         ParticlePusher::PHOTON,
                                          false,
-                                         Cooling::NONE,
+                                         RadiativeDrag::NONE,
+                                         EmissionType::COMPTON,
                                          5);
     testParticles<Dim::_2D, Coord::Sph>(4,
                                         "e+",
                                         1.0,
                                         1.0,
                                         100,
-                                        PrtlPusher::BORIS,
+                                        ParticlePusher::BORIS,
                                         true,
-                                        Cooling::NONE,
+                                        RadiativeDrag::NONE,
+                                        EmissionType::NONE,
                                         2,
                                         3);
     testParticles<Dim::_2D, Coord::Qsph>(5,
@@ -152,9 +163,10 @@ auto main(int argc, char** argv) -> int {
                                          1.0,
                                          1.0,
                                          100,
-                                         PrtlPusher::BORIS,
+                                         ParticlePusher::BORIS,
                                          false,
-                                         Cooling::NONE,
+                                         RadiativeDrag::NONE,
+                                         EmissionType::NONE,
                                          1,
                                          2);
   } catch (const std::exception& e) {
diff --git a/src/global/CMakeLists.txt b/src/global/CMakeLists.txt
index 7546b6a98..875698d97 100644
--- a/src/global/CMakeLists.txt
+++ b/src/global/CMakeLists.txt
@@ -11,6 +11,7 @@
 # * utils/timer.cpp
 # * utils/diag.cpp
 # * utils/progressbar.cpp
+# * utils/reporter.cpp
 #
 # @includes:
 #
@@ -25,9 +26,13 @@
 
 set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(SOURCES
-    ${SRC_DIR}/global.cpp ${SRC_DIR}/arch/kokkos_aliases.cpp
-    ${SRC_DIR}/utils/cargs.cpp ${SRC_DIR}/utils/timer.cpp
-    ${SRC_DIR}/utils/diag.cpp ${SRC_DIR}/utils/progressbar.cpp)
+    ${SRC_DIR}/global.cpp
+    ${SRC_DIR}/arch/kokkos_aliases.cpp
+    ${SRC_DIR}/utils/cargs.cpp
+    ${SRC_DIR}/utils/timer.cpp
+    ${SRC_DIR}/utils/diag.cpp
+    ${SRC_DIR}/utils/progressbar.cpp
+    ${SRC_DIR}/utils/reporter.cpp)
 if(${output})
   list(APPEND SOURCES ${SRC_DIR}/utils/param_container.cpp)
 endif()
@@ -36,4 +41,7 @@ target_include_directories(
   ntt_global
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(ntt_global PRIVATE stdc++fs)
+if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+  target_link_libraries(ntt_global PRIVATE stdc++fs)
+endif()
+
diff --git a/src/global/arch/kokkos_aliases.h b/src/global/arch/kokkos_aliases.h
index 06fff56ac..ea10ea4e1 100644
--- a/src/global/arch/kokkos_aliases.h
+++ b/src/global/arch/kokkos_aliases.h
@@ -41,7 +41,7 @@ using array_h_t = Kokkos::View<T, Kokkos::HostSpace>;
 
 // Array mirror alias of arbitrary type
 template <typename T>
-using array_mirror_t = typename array_t<T>::HostMirror;
+using array_mirror_t = typename array_t<T>::host_mirror_type;
 
 // Scatter view alias of arbitrary type
 template <typename T>
@@ -107,7 +107,7 @@ using ndfield_t = typename kokkos_aliases_hidden::ndfield_impl<D, N>::type;
 
 // D x N dimensional array (host memspace) for storing fields on ND hypercube
 template <Dimension D, unsigned short N>
-using ndfield_mirror_t = typename ndfield_t<D, N>::HostMirror;
+using ndfield_mirror_t = typename ndfield_t<D, N>::host_mirror_type;
 
 // D x N dimensional scatter array for storing fields on ND hypercubes
 namespace kokkos_aliases_hidden {
diff --git a/src/global/arch/traits.h b/src/global/arch/traits.h
index 269e76fc0..88a81a518 100644
--- a/src/global/arch/traits.h
+++ b/src/global/arch/traits.h
@@ -2,24 +2,15 @@
  * @file arch/traits.h
  * @brief Defines a set of traits to check if a class satisfies certain conditions
  * @implements
+ *   - traits::fieldsetter::ex1_t, ::ex2_t, ::ex3_t - checks for special methods in field setter classes
+ *   - traits::fieldsetter::bx1_t, ::bx2_t, ::bx3_t - checks for special methods in field setter classes
+ *   - traits::fieldsetter::dx1_t, ::dx2_t, ::dx3_t - checks for special methods in field setter classes
  *   - traits::has_method<>
  *   - traits::has_member<>
  *   - traits::ex1_t, ::ex2_t, ::ex3_t
  *   - traits::bx1_t, ::bx2_t, ::bx3_t
  *   - traits::dx1_t, ::dx2_t, ::dx3_t
  *   - traits::run_t, traits::to_string_t
- *   - traits::pgen::init_flds_t
- *   - traits::pgen::ext_force_t
- *   - traits::pgen::ext_current_t
- *   - traits::pgen::atm_fields_t
- *   - traits::pgen::match_fields_const_t
- *   - traits::pgen::match_fields_t
- *   - traits::pgen::fix_fields_const_t
- *   - traits::pgen::fix_fields_t
- *   - traits::pgen::init_prtls_t
- *   - traits::pgen::custom_fields_t
- *   - traits::pgen::custom_field_output_t
- *   - traits::pgen::custom_poststep_t
  *   - traits::check_compatibility<>
  *   - traits::compatibility<>
  *   - traits::is_pair<>
@@ -32,11 +23,63 @@
 #ifndef GLOBAL_ARCH_TRAITS_H
 #define GLOBAL_ARCH_TRAITS_H
 
+#include "global.h"
+
+#include <concepts>
+#include <string>
 #include <type_traits>
 #include <utility>
 
 namespace traits {
 
+  namespace fieldsetter {
+    // special ::ex1, ::ex2, ::ex3, ::bx1, ::bx2, ::bx3, ::dx1, ::dx2, ::dx3 methods
+    template <class T, Dimension D>
+    concept HasEx1 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.ex1(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasEx2 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.ex2(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasEx3 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.ex3(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasBx1 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.bx1(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasBx2 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.bx2(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasBx3 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.bx3(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasDx1 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.dx1(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasDx2 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.dx2(x_Ph) } -> std::convertible_to<real_t>;
+    };
+
+    template <class T, Dimension D>
+    concept HasDx3 = requires(const T& t, const coord_t<D>& x_Ph) {
+      { t.dx3(x_Ph) } -> std::convertible_to<real_t>;
+    };
+  } // namespace fieldsetter
+
   template <template <typename> class Trait, typename T, typename = void>
   struct has_method : std::false_type {};
 
@@ -50,135 +93,28 @@ namespace traits {
   template <template <typename> class Trait, typename T>
   struct has_member<Trait, T, std::void_t<Trait<T>>> : std::true_type {};
 
-  // for fieldsetter
-  // special ::ex1, ::ex2, ::ex3, ::bx1, ::bx2, ::bx3, ::dx1, ::dx2, ::dx3
-  template <typename T>
-  using ex1_t = decltype(&T::ex1);
-
-  template <typename T>
-  using ex2_t = decltype(&T::ex2);
-
-  template <typename T>
-  using ex3_t = decltype(&T::ex3);
-
-  template <typename T>
-  using bx1_t = decltype(&T::bx1);
-
-  template <typename T>
-  using bx2_t = decltype(&T::bx2);
-
-  template <typename T>
-  using bx3_t = decltype(&T::bx3);
-
-  template <typename T>
-  using dx1_t = decltype(&T::dx1);
-
-  template <typename T>
-  using dx2_t = decltype(&T::dx2);
-
-  template <typename T>
-  using dx3_t = decltype(&T::dx3);
-
-  // for simengine
-  template <typename T>
-  using run_t = decltype(&T::run);
-
-  // for params
-  template <typename T>
-  using to_string_t = decltype(&T::to_string);
-
-  // for pgen
-  namespace pgen {
-    template <typename T>
-    using init_flds_t = decltype(&T::init_flds);
-
-    template <typename T>
-    using init_prtls_t = decltype(&T::InitPrtls);
-
-    template <typename T>
-    using ext_force_t = decltype(&T::ext_force);
-
-    template <typename T>
-    using ext_current_t = decltype(&T::ext_current);
-
-    template <typename T>
-    using atm_fields_t = decltype(&T::AtmFields);
-
-    template <typename T>
-    using match_fields_t = decltype(&T::MatchFields);
-
-    template <typename T>
-    using match_fields_in_x1_t = decltype(&T::MatchFieldsInX1);
-
-    template <typename T>
-    using match_fields_in_x2_t = decltype(&T::MatchFieldsInX2);
-
-    template <typename T>
-    using match_fields_in_x3_t = decltype(&T::MatchFieldsInX3);
-
-    template <typename T>
-    using match_fields_const_t = decltype(&T::MatchFieldsConst);
-
-    template <typename T>
-    using fix_fields_t = decltype(&T::FixFields);
-
-    template <typename T>
-    using fix_fields_const_t = decltype(&T::FixFieldsConst);
-
-    template <typename T>
-    using perfect_conductor_fields_t = decltype(&T::PerfectConductorFields);
-
-    template <typename T>
-    using perfect_conductor_fields_const_t = decltype(&T::PerfectConductorFieldsConst);
-
-    template <typename T>
-    using perfect_conductor_currents_t = decltype(&T::PerfectConductorCurrents);
-
-    template <typename T>
-    using perfect_conductor_currents_const_t = decltype(&T::PerfectConductorCurrentsConst);
-
-    template <typename T>
-    using custom_fields_t = decltype(&T::CustomFields);
-
-    template <typename T>
-    using custom_poststep_t = decltype(&T::CustomPostStep);
-
-    template <typename T>
-    using custom_field_output_t = decltype(&T::CustomFieldOutput);
-
-    template <typename T>
-    using custom_stat_t = decltype(&T::CustomStat);
-  } // namespace pgen
-
   // for pgen extforce
   template <typename T>
   using species_t = decltype(&T::species);
 
-  // checking compat for the problem generator + engine
-  template <int N>
-  struct check_compatibility {
-    template <int... Is>
-    static constexpr bool value(std::integer_sequence<int, Is...>) {
-      return ((Is == N) || ...);
-    }
-  };
-
-  template <int... Is>
-  struct compatible_with {
-    static constexpr auto value = std::integer_sequence<int, Is...> {};
-  };
-
   template <typename>
   struct always_false : std::false_type {};
 
   // generic
-
   template <typename T>
   struct is_pair : std::false_type {};
 
   template <typename T, typename U>
   struct is_pair<std::pair<T, U>> : std::true_type {};
 
+  // c++20
+  namespace params {
+    template <class P>
+    concept HasToString = requires(const P& params) {
+      { params.to_string() } -> std::convertible_to<std::string>;
+    };
+  } // namespace params
+
 } // namespace traits
 
 #endif // GLOBAL_ARCH_TRAITS_H
diff --git a/src/global/defaults.h b/src/global/defaults.h
index 96b17f1f7..dbe37ef0f 100644
--- a/src/global/defaults.h
+++ b/src/global/defaults.h
@@ -97,11 +97,15 @@ namespace ntt::defaults {
   } // namespace gca
 
   namespace synchrotron {
-    const real_t gamma_rad = 1.0;
+    const real_t energy_min = 1e-3;
+    const real_t gamma_rad  = 1.0;
+    const real_t gamma_qed  = 10.0;
   } // namespace synchrotron
 
   namespace compton {
-    const real_t gamma_rad = 1.0;
+    const real_t energy_min = 1e-3;
+    const real_t gamma_rad  = 1.0;
+    const real_t gamma_qed  = 10.0;
   } // namespace compton
 } // namespace ntt::defaults
 
diff --git a/src/global/enums.h b/src/global/enums.h
index 4b11604dc..8949db506 100644
--- a/src/global/enums.h
+++ b/src/global/enums.h
@@ -10,12 +10,15 @@
  *                                    reflect, horizon, axis, sync
  *   - enum ntt::FldsBC            // periodic, match, fixed, atmosphere,
  *                                    custom, horizon, axis, conductor, sync
- *   - enum ntt::PrtlPusher        // boris, vay, photon, none
- *   - enum ntt::Cooling           // compton, synchrotron, none
  *   - enum ntt::FldsID            // e, dive, d, divd, b, h, j,
  *                                    a, t, rho, charge, n, nppc, v, custom
  *   - enum ntt::StatsID           // b^2, e^2, exb, j.e, t, rho,
  *                                    charge, n, npart
+ *
+ *   - enum ntt::ParticlePusher    // photon, boris, vay, gca, none
+ *   - enum ntt::RadiativeDrag     // compton, synchrotron, none
+ *   - enum ntt::EmissionType      // none, synchrotron, inversecompton
+ *
  * @namespaces:
  *   - ntt::
  * @note Enums of the same type can be compared with each other and with strings
@@ -27,16 +30,16 @@
  * example: SimEngine(SimEngine::SRPIC).to_string() [return "srpic"]
  * @note
  * To check if a string is a valid option, use the contains() function
- * example: PrtlPusher::contains("vay") == true
+ * example: PrtlBC::contains("periodic") == true
  * @note
  * To get the proper enum instance from a string, use the pick() function
- * example: PrtlPusher::pick("vay") [returns PrtlPusher(PrtlPusher::VAY)]
+ * example: PrtlBC::pick("periodic") [returns PrtlBC::PERIODIC]
  * @note
  * To get the total number of enum instances, use the total variable
- * example: Cooling::total == 2
+ * example: SimEngine::total == 2
  * @note
  * To iterate over all enum instances, use the variants array
- * example: for (Cooling c : Cooling::variants) { ... }
+ * example: for (auto s : SimEngine::variants) { ... }
  */
 
 #ifndef GLOBAL_ENUMS_H
@@ -240,42 +243,6 @@ namespace ntt {
     static constexpr std::size_t total = sizeof(variants) / sizeof(variants[0]);
   };
 
-  struct PrtlPusher : public enums_hidden::BaseEnum<PrtlPusher> {
-    static constexpr const char* label = "prtl_pusher";
-
-    enum type : uint8_t {
-      INVALID = 0,
-      BORIS   = 1,
-      VAY     = 2,
-      PHOTON  = 3,
-      NONE    = 4,
-    };
-
-    constexpr PrtlPusher(uint8_t c)
-      : enums_hidden::BaseEnum<PrtlPusher> { c } {}
-
-    static constexpr type variants[] = { BORIS, VAY, PHOTON, NONE };
-    static constexpr const char* lookup[] = { "boris", "vay", "photon", "none" };
-    static constexpr std::size_t total = sizeof(variants) / sizeof(variants[0]);
-  };
-
-  struct Cooling : public enums_hidden::BaseEnum<Cooling> {
-    static constexpr const char* label = "cooling";
-
-    enum type : uint8_t {
-      INVALID     = 0,
-      SYNCHROTRON = 1,
-      COMPTON     = 2,
-      NONE        = 3,
-    };
-
-    constexpr Cooling(uint8_t c) : enums_hidden::BaseEnum<Cooling> { c } {}
-
-    static constexpr type variants[] = { SYNCHROTRON, COMPTON, NONE };
-    static constexpr const char* lookup[] = { "synchrotron", "compton", "none" };
-    static constexpr std::size_t total = sizeof(variants) / sizeof(variants[0]);
-  };
-
   struct FldsID : public enums_hidden::BaseEnum<FldsID> {
     static constexpr const char* label = "out_flds";
 
@@ -337,6 +304,91 @@ namespace ntt {
     static constexpr std::size_t total = sizeof(variants) / sizeof(variants[0]);
   };
 
+  namespace ParticlePusher {
+    enum ParticlePusherFlags_ {
+      NONE   = 0,
+      PHOTON = 1 << 0,
+      BORIS  = 1 << 1,
+      VAY    = 1 << 2,
+      GCA    = 1 << 3,
+    };
+
+    inline auto to_string(int flags) -> std::string {
+      if (flags == NONE) {
+        return "none";
+      } else {
+        std::string result = "";
+        if (flags & PHOTON) {
+          result += "photon";
+        } else if (flags & BORIS) {
+          result += "boris";
+        } else if (flags & VAY) {
+          result += "vay";
+        }
+        if (flags & GCA) {
+          if (!result.empty()) {
+            result += ",";
+          }
+          result += "gca";
+        }
+        return result;
+      }
+    }
+  } // namespace ParticlePusher
+
+  typedef int ParticlePusherFlags;
+
+  namespace RadiativeDrag {
+    enum RadiativeDragFlags_ {
+      NONE        = 0,
+      SYNCHROTRON = 1 << 0,
+      COMPTON     = 1 << 1,
+    };
+
+    inline auto to_string(int flags) -> std::string {
+      if (flags == NONE) {
+        return "none";
+      } else {
+        std::string result = "";
+        if (flags & SYNCHROTRON) {
+          result += "synchrotron";
+        }
+        if (flags & COMPTON) {
+          if (!result.empty()) {
+            result += ",";
+          }
+          result += "compton";
+        }
+        return result;
+      }
+    }
+  } // namespace RadiativeDrag
+
+  typedef int RadiativeDragFlags;
+
+  namespace EmissionType {
+    enum EmissionTypeFlag_ {
+      NONE        = 0,
+      SYNCHROTRON = 1,
+      COMPTON     = 2,
+    };
+
+    inline auto to_string(int flags) -> std::string {
+      switch (flags) {
+        case NONE:
+          return "none";
+        case SYNCHROTRON:
+          return "synchrotron";
+        case COMPTON:
+          return "compton";
+        default:
+          return "unknown";
+      }
+    }
+  } // namespace EmissionType
+
+  typedef int EmissionTypeFlag;
+
 } // namespace ntt
 
 #endif // GLOBAL_ENUMS_H
diff --git a/src/global/tests/CMakeLists.txt b/src/global/tests/CMakeLists.txt
index c206f85b0..c9b479409 100644
--- a/src/global/tests/CMakeLists.txt
+++ b/src/global/tests/CMakeLists.txt
@@ -35,3 +35,4 @@ gen_test(comparators)
 gen_test(numeric)
 gen_test(param_container)
 gen_test(sorting)
+# gen_test(traits)
diff --git a/src/global/tests/enums.cpp b/src/global/tests/enums.cpp
index c70572be4..8a28f96e4 100644
--- a/src/global/tests/enums.cpp
+++ b/src/global/tests/enums.cpp
@@ -64,8 +64,6 @@ auto main() -> int {
   enum_str_t all_fields_bcs   = { "periodic",   "match",     "fixed",
                                   "atmosphere", "custom",    "horizon",
                                   "axis",       "conductor", "sync" };
-  enum_str_t all_particle_pushers = { "boris", "vay", "photon", "none" };
-  enum_str_t all_coolings         = { "synchrotron", "compton", "none" };
 
   enum_str_t all_out_flds = { "e",      "dive", "d",    "divd", "b",
                               "h",      "j",    "a",    "t",    "rho",
@@ -79,8 +77,6 @@ auto main() -> int {
   checkEnum<SimEngine>(all_simulation_engines);
   checkEnum<PrtlBC>(all_particle_bcs);
   checkEnum<FldsBC>(all_fields_bcs);
-  checkEnum<PrtlPusher>(all_particle_pushers);
-  checkEnum<Cooling>(all_coolings);
   checkEnum<FldsID>(all_out_flds);
   checkEnum<StatsID>(all_out_stats);
 
diff --git a/src/global/utils/colors.h b/src/global/utils/colors.h
index b997317cb..7afa6048c 100644
--- a/src/global/utils/colors.h
+++ b/src/global/utils/colors.h
@@ -53,7 +53,8 @@ namespace color {
     return msg_nocol;
   }
 
-  inline auto get_color(const std::string& s, bool eight_bit = true) -> std::string {
+  inline auto get_color(const std::string& s, bool eight_bit = true)
+    -> std::string {
     if (not eight_bit) {
       return "";
     } else {
diff --git a/src/global/utils/formatting.h b/src/global/utils/formatting.h
index 46c25c633..329909a98 100644
--- a/src/global/utils/formatting.h
+++ b/src/global/utils/formatting.h
@@ -26,6 +26,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace fmt {
@@ -53,10 +54,8 @@ namespace fmt {
    * @param c Character to pad with
    * @param right Pad on the right
    */
-  inline auto pad(const std::string& str,
-                  std::size_t        n,
-                  char               c,
-                  bool               right = false) -> std::string {
+  inline auto pad(const std::string& str, std::size_t n, char c, bool right = false)
+    -> std::string {
     if (n <= str.size()) {
       return str;
     }
@@ -69,14 +68,27 @@ namespace fmt {
   /**
    * @brief formats a vector of arbitrary type: [a, b, c, ...]
    */
+  template <class P>
+  concept HasToString = requires(const P& params) {
+    { params.to_string() } -> std::convertible_to<std::string>;
+  };
+
+  // generic
+
+  template <typename T>
+  struct is_pair : std::false_type {};
+
+  template <typename T, typename U>
+  struct is_pair<std::pair<T, U>> : std::true_type {};
+
   template <typename T>
   auto formatVector(const std::vector<T>& vec) -> std::string {
     std::ostringstream oss;
     oss << "[";
     if (!vec.empty()) {
       if constexpr (traits::is_pair<T>::value) {
-        if constexpr (
-          traits::has_method<traits::to_string_t, typename T::first_type>::value) {
+        if constexpr (HasToString<typename T::first_type> and
+                      HasToString<typename T::second_type>) {
           oss << "{" << vec[0].first.to_string() << ", "
               << vec[0].second.to_string() << "}";
           for (size_t i = 1; i < vec.size(); ++i) {
@@ -115,8 +127,8 @@ namespace fmt {
    * @param delim Delimiter
    * @return Vector of strings
    */
-  inline auto splitString(const std::string& str,
-                          const std::string& delim) -> std::vector<std::string> {
+  inline auto splitString(const std::string& str, const std::string& delim)
+    -> std::vector<std::string> {
     std::regex regexz(delim);
     return { std::sregex_token_iterator(str.begin(), str.end(), regexz, -1),
              std::sregex_token_iterator() };
diff --git a/src/global/utils/numeric.h b/src/global/utils/numeric.h
index 0be0e4a0f..e8495a488 100644
--- a/src/global/utils/numeric.h
+++ b/src/global/utils/numeric.h
@@ -26,8 +26,6 @@
 #ifndef GLOBAL_UTILS_NUMERIC_H
 #define GLOBAL_UTILS_NUMERIC_H
 
-#include "arch/kokkos_aliases.h"
-
 #include <cstdint>
 
 #if defined(SINGLE_PRECISION)
@@ -61,7 +59,7 @@ inline constexpr double ZERO          = 0.0;
 inline constexpr double HALF          = 0.5;
 inline constexpr double THIRD         = 0.3333333333333333;
 inline constexpr double THREE_FOURTHS = 0.75;
-inline constexpr float  THREE_HALFS   = 1.5;
+inline constexpr double THREE_HALFS   = 1.5;
 inline constexpr double INV_2         = 0.5;
 inline constexpr double INV_4         = 0.25;
 inline constexpr double INV_8         = 0.125;
diff --git a/src/global/utils/param_container.cpp b/src/global/utils/param_container.cpp
index 126a64e4e..bd8399bc8 100644
--- a/src/global/utils/param_container.cpp
+++ b/src/global/utils/param_container.cpp
@@ -5,7 +5,7 @@
   #include "global.h"
 
   #include <adios2.h>
-  #include <adios2/cxx11/KokkosView.h>
+  #include <adios2/cxx/KokkosView.h>
 
   #include <any>
   #include <functional>
@@ -235,7 +235,6 @@ namespace prm {
     register_write_function<ntt::Coord>();
     register_write_function<ntt::Metric>();
     register_write_function<ntt::SimEngine>();
-    register_write_function<ntt::PrtlPusher>();
 
     register_write_function_for_pair<float>();
     register_write_function_for_pair<double>();
@@ -254,7 +253,6 @@ namespace prm {
     register_write_function_for_pair<ntt::Coord>();
     register_write_function_for_pair<ntt::Metric>();
     register_write_function_for_pair<ntt::SimEngine>();
-    register_write_function_for_pair<ntt::PrtlPusher>();
 
     register_write_function_for_vector<float>();
     register_write_function_for_vector<double>();
@@ -273,7 +271,6 @@ namespace prm {
     register_write_function_for_vector<ntt::Coord>();
     register_write_function_for_vector<ntt::Metric>();
     register_write_function_for_vector<ntt::SimEngine>();
-    register_write_function_for_vector<ntt::PrtlPusher>();
 
     register_write_function_for_vector_of_pair<float>();
     register_write_function_for_vector_of_pair<double>();
@@ -292,7 +289,6 @@ namespace prm {
     register_write_function_for_vector_of_pair<ntt::Coord>();
     register_write_function_for_vector_of_pair<ntt::Metric>();
     register_write_function_for_vector_of_pair<ntt::SimEngine>();
-    register_write_function_for_vector_of_pair<ntt::PrtlPusher>();
 
     register_write_function_for_vector_of_vector<float>();
     register_write_function_for_vector_of_vector<double>();
@@ -311,7 +307,6 @@ namespace prm {
     register_write_function_for_vector_of_vector<ntt::Coord>();
     register_write_function_for_vector_of_vector<ntt::Metric>();
     register_write_function_for_vector_of_vector<ntt::SimEngine>();
-    register_write_function_for_vector_of_vector<ntt::PrtlPusher>();
 
     register_write_function_for_dict<float>();
     register_write_function_for_dict<double>();
diff --git a/src/global/utils/param_container.h b/src/global/utils/param_container.h
index 679b80552..2346de2b9 100644
--- a/src/global/utils/param_container.h
+++ b/src/global/utils/param_container.h
@@ -18,7 +18,7 @@
 
 #if defined(OUTPUT_ENABLED)
   #include <adios2.h>
-  #include <adios2/cxx11/KokkosView.h>
+  #include <adios2/cxx/KokkosView.h>
 #endif
 
 #include <any>
diff --git a/src/global/utils/reporter.cpp b/src/global/utils/reporter.cpp
new file mode 100644
index 000000000..9f1d50c9c
--- /dev/null
+++ b/src/global/utils/reporter.cpp
@@ -0,0 +1,249 @@
+#include "utils/reporter.h"
+
+#include "utils/colors.h"
+#include "utils/error.h"
+#include "utils/formatting.h"
+
+#if defined(CUDA_ENABLED)
+  #include <cuda_runtime.h>
+#elif defined(HIP_ENABLED)
+  #include <hip/hip_runtime.h>
+#endif
+
+#if defined(OUTPUT_ENABLED)
+  #include <adios2.h>
+#endif
+
+#include <Kokkos_Core.hpp>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace reporter {
+  void AddHeader(std::string&                    report,
+                 const std::vector<std::string>& lines,
+                 const std::vector<const char*>& colors) {
+    report += fmt::format("%s╔%s╗%s\n",
+                          color::BRIGHT_BLACK,
+                          fmt::repeat("═", 58).c_str(),
+                          color::RESET);
+    for (auto i { 0u }; i < lines.size(); ++i) {
+      report += fmt::format("%s║%s %s%s%s%s%s║%s\n",
+                            color::BRIGHT_BLACK,
+                            color::RESET,
+                            colors[i],
+                            lines[i].c_str(),
+                            color::RESET,
+                            fmt::repeat(" ", 57 - lines[i].size()).c_str(),
+                            color::BRIGHT_BLACK,
+                            color::RESET);
+    }
+    report += fmt::format("%s╚%s╝%s\n",
+                          color::BRIGHT_BLACK,
+                          fmt::repeat("═", 58).c_str(),
+                          color::RESET);
+  }
+
+  void AddCategory(std::string& report, unsigned short indent, const char* name) {
+    report += fmt::format("%s%s%s%s\n",
+                          std::string(indent, ' ').c_str(),
+                          color::BLUE,
+                          name,
+                          color::RESET);
+  }
+
+  void AddSubcategory(std::string& report, unsigned short indent, const char* name) {
+    report += fmt::format("%s%s-%s %s:\n",
+                          std::string(indent, ' ').c_str(),
+                          color::BRIGHT_BLACK,
+                          color::RESET,
+                          name);
+  }
+
+  void AddLabel(std::string& report, unsigned short indent, const char* label) {
+    report += fmt::format("%s%s\n", std::string(indent, ' ').c_str(), label);
+  }
+
+  auto Bytes2HumanReadable(std::size_t bytes) -> std::pair<double, std::string> {
+    const std::vector<std::string> units { "B", "KB", "MB", "GB", "TB" };
+    idx_t                          unit_idx = 0;
+    auto                           size     = static_cast<double>(bytes);
+    while ((size >= 1024.0) and (unit_idx < units.size() - 1)) {
+      size /= 1024.0;
+      ++unit_idx;
+    }
+    return { size, units[unit_idx] };
+  }
+
+  auto Backend() -> std::string {
+    std::string report = "";
+#if defined(MPI_ENABLED)
+    int mpi_v, mpi_subv;
+    MPI_Get_version(&mpi_v, &mpi_subv);
+    const std::string mpi_version = fmt::format("%d.%d", mpi_v, mpi_subv);
+#else  // not MPI_ENABLED
+    const std::string mpi_version = "OFF";
+#endif // MPI_ENABLED
+
+    const auto entity_version = "Entity v" + std::string(ENTITY_VERSION);
+    const auto hash           = std::string(ENTITY_GIT_HASH);
+    const auto precision      = (sizeof(real_t) == 4) ? "single" : "double";
+
+#if defined(__clang__)
+    const std::string ccx = "Clang/LLVM " __clang_version__;
+#elif defined(__ICC) || defined(__INTEL_COMPILER)
+    const std::string ccx = "Intel ICC/ICPC " __VERSION__;
+#elif defined(__GNUC__) || defined(__GNUG__)
+    const std::string ccx = "GNU GCC/G++ " __VERSION__;
+#elif defined(__HP_cc) || defined(__HP_aCC)
+    const std::string ccx = "Hewlett-Packard C/aC++ " __HP_aCC;
+#elif defined(__IBMC__) || defined(__IBMCPP__)
+    const std::string ccx = "IBM XL C/C++ " __IBMCPP__;
+#elif defined(_MSC_VER)
+    const std::string ccx = "Microsoft Visual Studio " _MSC_VER;
+#else
+    const std::string ccx = "Unknown compiler";
+#endif
+    std::string cpp_standard;
+    if (__cplusplus == 202101L) {
+      cpp_standard = "C++23";
+    } else if (__cplusplus == 202002L) {
+      cpp_standard = "C++20";
+    } else if (__cplusplus == 201703L) {
+      cpp_standard = "C++17";
+    } else if (__cplusplus == 201402L) {
+      cpp_standard = "C++14";
+    } else if (__cplusplus == 201103L) {
+      cpp_standard = "C++11";
+    } else if (__cplusplus == 199711L) {
+      cpp_standard = "C++98";
+    } else {
+      cpp_standard = "pre-standard " + std::to_string(__cplusplus);
+    }
+
+#if defined(CUDA_ENABLED)
+    int cuda_v;
+    cudaRuntimeGetVersion(&cuda_v);
+    const auto major { cuda_v / 1000 };
+    const auto minor { cuda_v % 1000 / 10 };
+    const auto patch { cuda_v % 10 };
+    const auto cuda_version = fmt::format("%d.%d.%d", major, minor, patch);
+#elif defined(HIP_ENABLED)
+    int  hip_v;
+    auto status = hipDriverGetVersion(&hip_v);
+    raise::ErrorIf(status != hipSuccess,
+                   "hipDriverGetVersion failed with error code %d",
+                   HERE);
+    const auto major { hip_v / 10000000 };
+    const auto minor { (hip_v % 10000000) / 100000 };
+    const auto patch { hip_v % 100000 };
+    const auto hip_version = fmt::format("%d.%d.%d", major, minor, patch);
+#endif
+
+    const auto kokkos_version = fmt::format("%d.%d.%d",
+                                            KOKKOS_VERSION / 10000,
+                                            KOKKOS_VERSION / 100 % 100,
+                                            KOKKOS_VERSION % 100);
+
+#if defined(OUTPUT_ENABLED)
+    const std::string adios2_version = fmt::format("%d.%d.%d",
+                                                   ADIOS2_VERSION / 10000,
+                                                   ADIOS2_VERSION / 100 % 100,
+                                                   ADIOS2_VERSION % 100);
+#else // not OUTPUT_ENABLED
+    const std::string adios2_version = "OFF";
+#endif
+
+#if defined(DEBUG)
+    const std::string dbg = "ON";
+#else // not DEBUG
+    const std::string dbg = "OFF";
+#endif
+
+    report += "\n\n";
+    AddHeader(report, { entity_version }, { color::BRIGHT_GREEN });
+    report += "\n";
+
+    /*
+     * Backend
+     */
+    AddCategory(report, 4, "Backend");
+    AddParam(report, 4, "Build hash", "%s", hash.c_str());
+    AddParam(report, 4, "CXX", "%s [%s]", ccx.c_str(), cpp_standard.c_str());
+#if defined(CUDA_ENABLED)
+    AddParam(report, 4, "CUDA", "%s", cuda_version.c_str());
+#elif defined(HIP_VERSION)
+    AddParam(report, 4, "HIP", "%s", hip_version.c_str());
+#endif
+    AddParam(report, 4, "MPI", "%s", mpi_version.c_str());
+#if defined(MPI_ENABLED) && defined(DEVICE_ENABLED)
+  #if defined(GPU_AWARE_MPI)
+    const std::string gpu_aware_mpi = "ON";
+  #else
+    const std::string gpu_aware_mpi = "OFF";
+  #endif
+    AddParam(report, 4, "GPU-aware MPI", "%s", gpu_aware_mpi.c_str());
+#endif
+    AddParam(report, 4, "Kokkos", "%s", kokkos_version.c_str());
+    AddParam(report, 4, "ADIOS2", "%s", adios2_version.c_str());
+    AddParam(report, 4, "Precision", "%s", precision);
+    AddParam(report, 4, "Debug", "%s", dbg.c_str());
+    report += "\n";
+
+    /*
+     * Compilation flags
+     */
+    AddCategory(report, 4, "Compilation flags");
+#if defined(SINGLE_PRECISION)
+    AddParam(report, 4, "SINGLE_PRECISION", "%s", "ON");
+#else
+    AddParam(report, 4, "SINGLE_PRECISION", "%s", "OFF");
+#endif
+
+#if defined(OUTPUT_ENABLED)
+    AddParam(report, 4, "OUTPUT_ENABLED", "%s", "ON");
+#else
+    AddParam(report, 4, "OUTPUT_ENABLED", "%s", "OFF");
+#endif
+
+#if defined(DEBUG)
+    AddParam(report, 4, "DEBUG", "%s", "ON");
+#else
+    AddParam(report, 4, "DEBUG", "%s", "OFF");
+#endif
+
+#if defined(CUDA_ENABLED)
+    AddParam(report, 4, "CUDA_ENABLED", "%s", "ON");
+#else
+    AddParam(report, 4, "CUDA_ENABLED", "%s", "OFF");
+#endif
+
+#if defined(HIP_ENABLED)
+    AddParam(report, 4, "HIP_ENABLED", "%s", "ON");
+#else
+    AddParam(report, 4, "HIP_ENABLED", "%s", "OFF");
+#endif
+
+#if defined(DEVICE_ENABLED)
+    AddParam(report, 4, "DEVICE_ENABLED", "%s", "ON");
+#else
+    AddParam(report, 4, "DEVICE_ENABLED", "%s", "OFF");
+#endif
+
+#if defined(MPI_ENABLED)
+    AddParam(report, 4, "MPI_ENABLED", "%s", "ON");
+#else
+    AddParam(report, 4, "MPI_ENABLED", "%s", "OFF");
+#endif
+
+#if defined(GPU_AWARE_MPI)
+    AddParam(report, 4, "GPU_AWARE_MPI", "%s", "ON");
+#else
+    AddParam(report, 4, "GPU_AWARE_MPI", "%s", "OFF");
+#endif
+    report += "\n";
+    return report;
+  }
+
+} // namespace reporter
diff --git a/src/global/utils/reporter.h b/src/global/utils/reporter.h
new file mode 100644
index 000000000..f582ecfe9
--- /dev/null
+++ b/src/global/utils/reporter.h
@@ -0,0 +1,58 @@
+#ifndef GLOBAL_UTILS_REPORTER_H
+#define GLOBAL_UTILS_REPORTER_H
+
+#include "utils/colors.h"
+#include "utils/formatting.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace reporter {
+  void AddHeader(std::string&,
+                 const std::vector<std::string>&,
+                 const std::vector<const char*>&);
+
+  void AddCategory(std::string&, unsigned short, const char*);
+
+  void AddSubcategory(std::string&, unsigned short, const char*);
+
+  void AddLabel(std::string&, unsigned short, const char*);
+
+  template <typename... Args>
+  void AddParam(std::string&   report,
+                unsigned short indent,
+                const char*    name,
+                const char*    format,
+                Args... args) {
+    report += fmt::format("%s%s-%s %s: %s%s%s\n",
+                          std::string(indent, ' ').c_str(),
+                          color::BRIGHT_BLACK,
+                          color::RESET,
+                          name,
+                          color::BRIGHT_YELLOW,
+                          fmt::format(format, args...).c_str(),
+                          color::RESET);
+  }
+
+  template <typename... Args>
+  void AddUnlabeledParam(std::string&   report,
+                         unsigned short indent,
+                         const char*    name,
+                         const char*    format,
+                         Args... args) {
+    report += fmt::format("%s%s: %s%s%s\n",
+                          std::string(indent, ' ').c_str(),
+                          name,
+                          color::BRIGHT_YELLOW,
+                          fmt::format(format, args...).c_str(),
+                          color::RESET);
+  }
+
+  auto Bytes2HumanReadable(std::size_t) -> std::pair<double, std::string>;
+
+  auto Backend() -> std::string;
+
+} // namespace reporter
+
+#endif // GLOBAL_UTILS_REPORTER_H
diff --git a/src/kernels/ampere_gr.hpp b/src/kernels/ampere_gr.hpp
index 327ce0cdf..24a2eb356 100644
--- a/src/kernels/ampere_gr.hpp
+++ b/src/kernels/ampere_gr.hpp
@@ -20,6 +20,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::gr {
   using namespace ntt;
 
@@ -29,8 +31,9 @@ namespace kernel::gr {
    * @tparam M Metric.
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M> && metric::traits::HasPolarArea<M>
   class Ampere_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     const ndfield_t<D, 6> Din;
@@ -73,18 +76,14 @@ namespace kernel::gr {
 
         if ((i2 == i2min) && is_axis_i2min) {
           // theta = 0
-          const real_t inv_polar_area_pH { ONE / metric.polar_area(i1_ + HALF) };
           const real_t inv_sqrt_detH_0pH { ONE / metric.sqrt_det_h({ i1_, HALF }) };
-          Dout(i1, i2, em::dx1) = Din(i1, i2, em::dx1) +
-                                  inv_polar_area_pH * coeff * H(i1, i2, em::hx3);
+          Dout(i1, i2, em::dx1) = Din(i1, i2 + 1, em::dx1);
           Dout(i1, i2, em::dx2) = Din(i1, i2, em::dx2) +
                                   coeff * inv_sqrt_detH_0pH *
                                     (H(i1 - 1, i2, em::hx3) - H(i1, i2, em::hx3));
         } else if ((i2 == i2max) && is_axis_i2max) {
           // theta = pi
-          const real_t inv_polar_area_pH { ONE / metric.polar_area(i1_ + HALF) };
-          Dout(i1, i2, em::dx1) = Din(i1, i2, em::dx1) - inv_polar_area_pH * coeff *
-                                                           H(i1, i2 - 1, em::hx3);
+          Dout(i1, i2, em::dx1) = Din(i1, i2 - 1, em::dx1);
         } else {
           const real_t inv_sqrt_detH_00 { ONE / metric.sqrt_det_h({ i1_, i2_ }) };
           const real_t inv_sqrt_detH_pH0 { ONE / metric.sqrt_det_h(
@@ -110,6 +109,8 @@ namespace kernel::gr {
    * @brief Add the currents to the D field with the appropriate conversion.
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M> && metric::traits::HasPolarArea<M>
   class CurrentsAmpere_kernel {
     static constexpr auto D = M::Dim;
 
diff --git a/src/kernels/ampere_sr.hpp b/src/kernels/ampere_sr.hpp
index dbe9d3dbf..01c96bdf9 100644
--- a/src/kernels/ampere_sr.hpp
+++ b/src/kernels/ampere_sr.hpp
@@ -20,6 +20,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::sr {
   using namespace ntt;
 
@@ -28,8 +30,9 @@ namespace kernel::sr {
    * @tparam M Metric
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M> && metric::traits::HasPolarArea<M>
   class Ampere_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     ndfield_t<D, 6> EB;
@@ -121,6 +124,8 @@ namespace kernel::sr {
    * @brief Add the currents to the E field with the appropriate conversion
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M> && metric::traits::HasPolarArea<M>
   class CurrentsAmpere_kernel {
     static constexpr auto     D     = M::Dim;
     static constexpr ncells_t i2min = N_GHOSTS;
diff --git a/src/kernels/aux_fields_gr.hpp b/src/kernels/aux_fields_gr.hpp
index 16ea11f46..c20a8be76 100644
--- a/src/kernels/aux_fields_gr.hpp
+++ b/src/kernels/aux_fields_gr.hpp
@@ -19,6 +19,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::gr {
   using namespace ntt;
 
@@ -27,8 +29,10 @@ namespace kernel::gr {
    * @tparam M Metric
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasSqrtDetH<M> &&
+             metric::traits::HasSqrtDetHTilde<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasAlpha<M> && metric::traits::HasBeta1<M>
   class ComputeAuxE_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     const ndfield_t<D, 6> Df;
@@ -134,8 +138,10 @@ namespace kernel::gr {
    * @tparam M Metric
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasSqrtDetH<M> &&
+             metric::traits::HasSqrtDetHTilde<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasAlpha<M> && metric::traits::HasBeta1<M>
   class ComputeAuxH_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     const ndfield_t<D, 6> Df;
@@ -241,22 +247,15 @@ namespace kernel::gr {
    * @brief Kernel for computing time average of B and D
    * @tparam M Metric
    */
-  template <class M>
+  template <Dimension D>
   class TimeAverageDB_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static constexpr auto D = M::Dim;
-
     const ndfield_t<D, 6> BDf;
     ndfield_t<D, 6>       BDf0;
-    const M               metric;
 
   public:
-    TimeAverageDB_kernel(const ndfield_t<D, 6>& BDf,
-                         const ndfield_t<D, 6>& BDf0,
-                         const M&               metric)
+    TimeAverageDB_kernel(const ndfield_t<D, 6>& BDf, const ndfield_t<D, 6>& BDf0)
       : BDf { BDf }
-      , BDf0 { BDf0 }
-      , metric { metric } {}
+      , BDf0 { BDf0 } {}
 
     Inline void operator()(index_t i1, index_t i2) const {
       if constexpr (D == Dim::_2D) {
@@ -284,22 +283,15 @@ namespace kernel::gr {
    * @brief Kernel for computing time average of J
    * @tparam M Metric
    */
-  template <class M>
+  template <Dimension D>
   class TimeAverageJ_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static constexpr auto D = M::Dim;
-
     ndfield_t<D, 3>       Jf;
     const ndfield_t<D, 3> Jf0;
-    const M               metric;
 
   public:
-    TimeAverageJ_kernel(const ndfield_t<D, 3>& Jf,
-                        const ndfield_t<D, 3>& Jf0,
-                        const M&               metric)
+    TimeAverageJ_kernel(const ndfield_t<D, 3>& Jf, const ndfield_t<D, 3>& Jf0)
       : Jf { Jf }
-      , Jf0 { Jf0 }
-      , metric { metric } {}
+      , Jf0 { Jf0 } {}
 
     Inline void operator()(index_t i1, index_t i2) const {
       if constexpr (D == Dim::_2D) {
diff --git a/src/kernels/currents_deposit.hpp b/src/kernels/currents_deposit.hpp
index 3bd205949..f8f16c699 100644
--- a/src/kernels/currents_deposit.hpp
+++ b/src/kernels/currents_deposit.hpp
@@ -17,6 +17,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include "particle_shapes.hpp"
 
 #include <Kokkos_Core.hpp>
@@ -30,8 +32,11 @@ namespace kernel {
    * @brief Algorithm for the current deposition
    */
   template <SimEngine::type S, class M, unsigned short O = 1u>
+    requires metric::traits::HasD<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasTransform<M> &&
+               metric::traits::HasConvert_i<M> && metric::traits::HasAlpha<M>))
   class DepositCurrents_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static_assert(O <= 11u, "Shape function order O must be <= 11");
     static constexpr auto D = M::Dim;
 
diff --git a/src/kernels/divergences.hpp b/src/kernels/divergences.hpp
index c60be564b..b7a894dd6 100644
--- a/src/kernels/divergences.hpp
+++ b/src/kernels/divergences.hpp
@@ -10,16 +10,21 @@
 #ifndef KERNELS_DIVERGENCES_HPP
 #define KERNELS_DIVERGENCES_HPP
 
+#include "enums.h"
 #include "global.h"
 
 #include "arch/kokkos_aliases.h"
 #include "utils/error.h"
+#include "utils/numeric.h"
+
+#include "metrics/traits.h"
 
 namespace kernel {
   using namespace ntt;
 
   // @TODO: take care of boundaries
   template <class M, unsigned short N>
+    requires metric::traits::HasD<M> && metric::traits::HasSqrtDetH<M>
   class ComputeDivergence_kernel {
     const M metric;
 
diff --git a/src/kernels/emission/compton.hpp b/src/kernels/emission/compton.hpp
new file mode 100644
index 000000000..32621f570
--- /dev/null
+++ b/src/kernels/emission/compton.hpp
@@ -0,0 +1,222 @@
+#ifndef KERNELS_EMISSION_COMPTON_HPP
+#define KERNELS_EMISSION_COMPTON_HPP
+
+#include "enums.h"
+#include "global.h"
+
+#include "metrics/traits.h"
+
+#include "framework/parameters/parameters.h"
+
+#include "kernels/injectors.hpp"
+
+#include <Kokkos_Pair.hpp>
+
+namespace kernel {
+  namespace emission {
+    using namespace ntt;
+
+    template <class M>
+      requires metric::traits::HasD<M> && metric::traits::HasCoordType<M> &&
+               metric::traits::HasPrtlDim<M>
+    struct Compton {
+      struct Payload {
+        real_t photon_energy;
+      };
+
+      const real_t species_mass;
+      const real_t emitted_photon_weight;
+      const real_t emitted_photon_min_energy;
+
+      const real_t nominal_probability;
+      const real_t nominal_photon_energy;
+
+      const bool should_drag;
+
+      array_t<int*>      photon_i1, photon_i2, photon_i3;
+      array_t<prtldx_t*> photon_dx1, photon_dx2, photon_dx3;
+      array_t<real_t*>   photon_ux1, photon_ux2, photon_ux3;
+      array_t<real_t*>   photon_phi;
+      array_t<real_t*>   photon_weight;
+      array_t<short*>    photon_tag;
+      array_t<npart_t**> photon_pld_i;
+
+      array_t<npart_t> photon_idx { "idx" };
+      const npart_t    photon_offset, photon_cntr, domain_idx;
+      const bool       photon_use_tracking;
+
+      random_number_pool_t random_pool;
+
+      Compton(Particles<M::Dim, M::CoordType>& photon_species,
+              float                            sp_mass,
+              float                            sp_charge,
+              RadiativeDragFlags               radiative_drag_flags,
+              real_t                           dt,
+              npart_t                          domain_idx,
+              const SimulationParams&          params,
+              random_number_pool_t&            random_pool)
+        : species_mass { static_cast<real_t>(sp_mass) }
+        , emitted_photon_weight { params.template get<real_t>(
+            "radiation.emission.compton.photon_weight") }
+        , emitted_photon_min_energy { params.template get<real_t>(
+            "radiation.emission.compton.photon_energy_min") }
+        , nominal_probability { math::abs(sp_charge / species_mass) *
+                                params.template get<real_t>(
+                                  "radiation.emission.compton.nominal_"
+                                  "probability") }
+        , nominal_photon_energy { species_mass * params.template get<real_t>(
+                                                   "radiation.emission.compton."
+                                                   "nominal_photon_energy") }
+        , should_drag { static_cast<bool>(radiative_drag_flags &
+                                          RadiativeDrag::COMPTON) }
+        , photon_i1 { photon_species.i1 }
+        , photon_i2 { photon_species.i2 }
+        , photon_i3 { photon_species.i3 }
+        , photon_dx1 { photon_species.dx1 }
+        , photon_dx2 { photon_species.dx2 }
+        , photon_dx3 { photon_species.dx3 }
+        , photon_ux1 { photon_species.ux1 }
+        , photon_ux2 { photon_species.ux2 }
+        , photon_ux3 { photon_species.ux3 }
+        , photon_phi { photon_species.phi }
+        , photon_weight { photon_species.weight }
+        , photon_tag { photon_species.tag }
+        , photon_pld_i { photon_species.pld_i }
+        , photon_offset { photon_species.npart() }
+        , photon_cntr { photon_species.counter() }
+        , domain_idx { domain_idx }
+        , photon_use_tracking { photon_species.use_tracking() }
+        , random_pool { random_pool } {}
+
+      auto number_injected() const -> npart_t {
+        auto photon_idx_h = Kokkos::create_mirror_view(photon_idx);
+        Kokkos::deep_copy(photon_idx_h, photon_idx);
+        return photon_idx_h();
+      }
+
+      /**
+       *
+       * @brief Determine whether a photon is emitted, the drag is applied,
+       *      and compute its energy and the recoil on the emitting particle
+       *
+       * @param x_Cd Position of the particle (code)
+       * @param x_Ph Position of the particle (physical)
+       * @param u_Ph Velocity of the particle (physical)
+       * @param ep Interpolated electric field at the particle position (physical)
+       * @param bp Interpolated magnetic field at the particle position (physical)
+       * @param delta_u_Ph Output parameter for the recoil on the emitting particle (physical units)
+       *
+       * @note
+       *
+       *   probability at each timestep is:
+       *      nominal_probability = omegaB0 * etarec * dt * (gamma_QED / gamma_rad)^2 / photon_weight
+       *      p_gamma = (q / q0) / (m / m0) * beta * nominal_probability
+       *
+       *   mean energy of the emitted photon [units of m0 c^2]:
+       *      nominal_photon_energy = (1 / gamma_QED)^2
+       *      e_gamma = (gamma)^2 * (m / m0) * nominal_photon_energy
+       *
+       *   drag acceleration * dt:
+       *      du = - photon_weight * p_gamma * e_gamma * u_hat / (m / m0)
+       *
+       *  @returns Pair of booleans to indicate whether a particle should be emitted
+       *      and whether the emitting particle should experience a recoil (i.e. radiative drag)
+       *
+       */
+      Inline auto shouldEmit(const coord_t<M::PrtlDim>&,
+                             const coord_t<M::PrtlDim>&,
+                             const vec_t<Dim::_3D>& u_Ph,
+                             const vec_t<Dim::_3D>&,
+                             const vec_t<Dim::_3D>&,
+                             vec_t<Dim::_3D>& delta_u_Ph,
+                             Payload& payload) const -> Kokkos::pair<bool, bool> {
+        const auto u_sqr     = NORM_SQR(u_Ph[0], u_Ph[1], u_Ph[2]);
+        const auto gamma_sqr = ONE + u_sqr;
+
+        payload.photon_energy = gamma_sqr * nominal_photon_energy;
+
+        const auto delta_u = -emitted_photon_weight * payload.photon_energy /
+                             (math::sqrt(u_sqr) * species_mass);
+
+        delta_u_Ph[0] = delta_u * u_Ph[0];
+        delta_u_Ph[1] = delta_u * u_Ph[1];
+        delta_u_Ph[2] = delta_u * u_Ph[2];
+
+        auto       rand_gen    = random_pool.get_state();
+        // should not emit if photon energy is above 20% of (gamma - 1) m c^2
+        const auto should_emit = (Random<real_t>(rand_gen) <
+                                  (nominal_probability *
+                                   math::sqrt(u_sqr / gamma_sqr))) and
+                                 (payload.photon_energy <
+                                  species_mass * (math::sqrt(gamma_sqr) - ONE) *
+                                    static_cast<real_t>(0.2));
+        random_pool.free_state(rand_gen);
+
+        return Kokkos::make_pair(
+          should_emit and (payload.photon_energy >= emitted_photon_min_energy),
+          should_drag and should_emit);
+      }
+
+      Inline void emit(const tuple_t<int, M::Dim>&      xi_Cd,
+                       const tuple_t<prtldx_t, M::Dim>& dxi_Cd,
+                       const vec_t<Dim::_3D>&           direction,
+                       real_t                           weight,
+                       real_t                           phi,
+                       const Payload&                   payload) const {
+        const auto index = Kokkos::atomic_fetch_add(&photon_idx(), 1);
+        if (not photon_use_tracking) {
+          kernel::InjectParticle<M::Dim, M::CoordType, false>(
+            photon_offset + index,
+            photon_i1,
+            photon_i2,
+            photon_i3,
+            photon_dx1,
+            photon_dx2,
+            photon_dx3,
+            photon_ux1,
+            photon_ux2,
+            photon_ux3,
+            photon_phi,
+            photon_weight,
+            photon_tag,
+            photon_pld_i,
+            xi_Cd,
+            dxi_Cd,
+            { direction[0] * payload.photon_energy,
+              direction[1] * payload.photon_energy,
+              direction[2] * payload.photon_energy },
+            emitted_photon_weight * weight,
+            phi);
+        } else {
+          kernel::InjectParticle<M::Dim, M::CoordType, true>(
+            photon_offset + index,
+            photon_i1,
+            photon_i2,
+            photon_i3,
+            photon_dx1,
+            photon_dx2,
+            photon_dx3,
+            photon_ux1,
+            photon_ux2,
+            photon_ux3,
+            photon_phi,
+            photon_weight,
+            photon_tag,
+            photon_pld_i,
+            xi_Cd,
+            dxi_Cd,
+            { direction[0] * payload.photon_energy,
+              direction[1] * payload.photon_energy,
+              direction[2] * payload.photon_energy },
+            emitted_photon_weight * weight,
+            phi,
+            domain_idx,
+            photon_cntr + index);
+        }
+      }
+    };
+
+  } // namespace emission
+} // namespace kernel
+
+#endif // KERNELS_EMISSION_COMPTON_HPP
diff --git a/src/kernels/emission/emission.hpp b/src/kernels/emission/emission.hpp
new file mode 100644
index 000000000..2cdc9cb69
--- /dev/null
+++ b/src/kernels/emission/emission.hpp
@@ -0,0 +1,14 @@
+#ifndef KERNELS_EMISSION_EMISSION_HPP
+#define KERNELS_EMISSION_EMISSION_HPP
+
+#include "enums.h"
+
+namespace kernel {
+  using namespace ntt;
+
+  template <SimEngine::type S, class M>
+  struct NoEmissionPolicy_t {};
+
+} // namespace kernel
+
+#endif
diff --git a/src/kernels/emission/synchrotron.hpp b/src/kernels/emission/synchrotron.hpp
new file mode 100644
index 000000000..1510d2c28
--- /dev/null
+++ b/src/kernels/emission/synchrotron.hpp
@@ -0,0 +1,274 @@
+#ifndef KERNELS_EMISSION_SYNCHROTRON_HPP
+#define KERNELS_EMISSION_SYNCHROTRON_HPP
+
+#include "enums.h"
+#include "global.h"
+
+#include "metrics/traits.h"
+
+#include "framework/parameters/parameters.h"
+
+#include "kernels/injectors.hpp"
+
+#include <Kokkos_Pair.hpp>
+
+namespace kernel {
+  namespace emission {
+    using namespace ntt;
+
+    template <class M>
+      requires metric::traits::HasD<M> && metric::traits::HasCoordType<M> &&
+               metric::traits::HasPrtlDim<M>
+    struct Synchrotron {
+      struct Payload {
+        real_t photon_energy;
+      };
+
+      const real_t species_mass;
+      const real_t emitted_photon_weight;
+      const real_t emitted_photon_min_energy;
+
+      const real_t nominal_probability;
+      const real_t nominal_photon_energy;
+
+      const bool should_drag;
+
+      array_t<int*>      photon_i1, photon_i2, photon_i3;
+      array_t<prtldx_t*> photon_dx1, photon_dx2, photon_dx3;
+      array_t<real_t*>   photon_ux1, photon_ux2, photon_ux3;
+      array_t<real_t*>   photon_phi;
+      array_t<real_t*>   photon_weight;
+      array_t<short*>    photon_tag;
+      array_t<npart_t**> photon_pld_i;
+
+      array_t<npart_t> photon_idx { "idx" };
+      const npart_t    photon_offset, photon_cntr, domain_idx;
+      const bool       photon_use_tracking;
+
+      random_number_pool_t random_pool;
+
+      Synchrotron(Particles<M::Dim, M::CoordType>& photon_species,
+                  float                            sp_mass,
+                  float                            sp_charge,
+                  RadiativeDragFlags               radiative_drag_flags,
+                  real_t                           dt,
+                  npart_t                          domain_idx,
+                  const SimulationParams&          params,
+                  random_number_pool_t&            random_pool)
+        : species_mass { static_cast<real_t>(sp_mass) }
+        , emitted_photon_weight { params.template get<real_t>(
+            "radiation.emission.synchrotron.photon_weight") }
+        , emitted_photon_min_energy { params.template get<real_t>(
+            "radiation.emission.synchrotron.photon_energy_min") }
+        , nominal_probability { math::abs(sp_charge / species_mass) *
+                                params.template get<real_t>(
+                                  "radiation.emission.synchrotron.nominal_"
+                                  "probability") }
+        , nominal_photon_energy { species_mass *
+                                  params.template get<real_t>(
+                                    "radiation.emission.synchrotron."
+                                    "nominal_photon_energy") }
+        , should_drag { static_cast<bool>(radiative_drag_flags &
+                                          RadiativeDrag::SYNCHROTRON) }
+        , photon_i1 { photon_species.i1 }
+        , photon_i2 { photon_species.i2 }
+        , photon_i3 { photon_species.i3 }
+        , photon_dx1 { photon_species.dx1 }
+        , photon_dx2 { photon_species.dx2 }
+        , photon_dx3 { photon_species.dx3 }
+        , photon_ux1 { photon_species.ux1 }
+        , photon_ux2 { photon_species.ux2 }
+        , photon_ux3 { photon_species.ux3 }
+        , photon_phi { photon_species.phi }
+        , photon_weight { photon_species.weight }
+        , photon_tag { photon_species.tag }
+        , photon_pld_i { photon_species.pld_i }
+        , photon_offset { photon_species.npart() }
+        , photon_cntr { photon_species.counter() }
+        , domain_idx { domain_idx }
+        , photon_use_tracking { photon_species.use_tracking() }
+        , random_pool { random_pool } {}
+
+      auto number_injected() const -> npart_t {
+        auto photon_idx_h = Kokkos::create_mirror_view(photon_idx);
+        Kokkos::deep_copy(photon_idx_h, photon_idx);
+        return photon_idx_h();
+      }
+
+      /**
+       *
+       * @brief Determine whether a photon is emitted, the drag is applied,
+       *      and compute its energy and the recoil on the emitting particle
+       *
+       * @param x_Cd Position of the particle (code)
+       * @param x_Ph Position of the particle (physical)
+       * @param u_Ph Velocity of the particle (physical)
+       * @param ep Interpolated electric field at the particle position (physical, units of B0)
+       * @param bp Interpolated magnetic field at the particle position (physical, units of B0)
+       * @param delta_u_Ph Output parameter for the recoil on the emitting particle (physical units)
+       *
+       * @note
+       *
+       *   probability at each timestep is:
+       *      nominal_probability = omegaB0 * etarec * dt * (gamma_QED / gamma_rad)^2 / photon_weight
+       *      kappaR = (e + beta x b) x b + (beta . e) e
+       *      chiR^2 = (e + beta x b)^2 - (beta . e)^2
+       *      p_gamma = (q / q0) / (m / m0) * nominal_probability * (-kappaR . beta_hat / gamma^2 + beta chiR^2)
+       *
+       *   mean energy of the emitted photon [units of m0 c^2]:
+       *      nominal_photon_energy = (1 / gamma_QED)^2
+       *      e_gamma = (gamma)^2 * (m / m0) * nominal_photon_energy
+       *
+       *   drag force [in units of m c]:
+       *      du / dt = - photon_weight * p_gamma * e_gamma * u_hat
+       *
+       *  @returns Pair of booleans to indicate whether a particle should be emitted
+       *      and whether the emitting particle should experience a recoil (i.e. radiative drag)
+       *
+       */
+      Inline auto shouldEmit(const coord_t<M::PrtlDim>&,
+                             const coord_t<M::PrtlDim>&,
+                             const vec_t<Dim::_3D>& u_Ph,
+                             const vec_t<Dim::_3D>& ep_Ph,
+                             const vec_t<Dim::_3D>& bp_Ph,
+                             vec_t<Dim::_3D>&       delta_u_Ph,
+                             Payload& payload) const -> Kokkos::pair<bool, bool> {
+        const auto u_sqr     = NORM_SQR(u_Ph[0], u_Ph[1], u_Ph[2]);
+        const auto u_mag     = math::sqrt(u_sqr);
+        const auto gamma_sqr = ONE + u_sqr;
+        const auto gamma     = math::sqrt(gamma_sqr);
+        const auto beta      = u_mag / gamma;
+
+        const auto e_plus_beta_cross_b_x1 =
+          ep_Ph[0] +
+          CROSS_x1(u_Ph[0], u_Ph[1], u_Ph[2], bp_Ph[0], bp_Ph[1], bp_Ph[2]) / gamma;
+        const auto e_plus_beta_cross_b_x2 =
+          ep_Ph[1] +
+          CROSS_x2(u_Ph[0], u_Ph[1], u_Ph[2], bp_Ph[0], bp_Ph[1], bp_Ph[2]) / gamma;
+        const auto e_plus_beta_cross_b_x3 =
+          ep_Ph[2] +
+          CROSS_x3(u_Ph[0], u_Ph[1], u_Ph[2], bp_Ph[0], bp_Ph[1], bp_Ph[2]) / gamma;
+        const auto beta_dot_e =
+          DOT(u_Ph[0], u_Ph[1], u_Ph[2], ep_Ph[0], ep_Ph[1], ep_Ph[2]) / gamma;
+
+        const auto kappaR_x1 = CROSS_x1(e_plus_beta_cross_b_x1,
+                                        e_plus_beta_cross_b_x2,
+                                        e_plus_beta_cross_b_x3,
+                                        bp_Ph[0],
+                                        bp_Ph[1],
+                                        bp_Ph[2]) +
+                               beta_dot_e * ep_Ph[0];
+        const auto kappaR_x2 = CROSS_x2(e_plus_beta_cross_b_x1,
+                                        e_plus_beta_cross_b_x2,
+                                        e_plus_beta_cross_b_x3,
+                                        bp_Ph[0],
+                                        bp_Ph[1],
+                                        bp_Ph[2]) +
+                               beta_dot_e * ep_Ph[1];
+        const auto kappaR_x3 = CROSS_x3(e_plus_beta_cross_b_x1,
+                                        e_plus_beta_cross_b_x2,
+                                        e_plus_beta_cross_b_x3,
+                                        bp_Ph[0],
+                                        bp_Ph[1],
+                                        bp_Ph[2]) +
+                               beta_dot_e * ep_Ph[2];
+        const auto chiR_sqr = NORM_SQR(e_plus_beta_cross_b_x1,
+                                       e_plus_beta_cross_b_x2,
+                                       e_plus_beta_cross_b_x3) -
+                              SQR(beta_dot_e);
+
+        const auto probability =
+          nominal_probability *
+          (-DOT(kappaR_x1, kappaR_x2, kappaR_x3, u_Ph[0], u_Ph[1], u_Ph[2]) /
+             (gamma_sqr * u_mag) +
+           beta * chiR_sqr);
+
+        const auto dir_x1 = -kappaR_x1 + gamma * u_Ph[0] * chiR_sqr;
+        const auto dir_x2 = -kappaR_x2 + gamma * u_Ph[1] * chiR_sqr;
+        const auto dir_x3 = -kappaR_x3 + gamma * u_Ph[2] * chiR_sqr;
+
+        payload.photon_energy = gamma_sqr * nominal_photon_energy;
+
+        const auto delta_u = -emitted_photon_weight * payload.photon_energy /
+                             (NORM(dir_x1, dir_x2, dir_x3) * species_mass);
+
+        delta_u_Ph[0] = delta_u * dir_x1;
+        delta_u_Ph[1] = delta_u * dir_x2;
+        delta_u_Ph[2] = delta_u * dir_x3;
+
+        auto       rand_gen    = random_pool.get_state();
+        // should not emit if photon energy is above 20% of (gamma - 1) m c^2
+        const auto should_emit = (Random<real_t>(rand_gen) < probability) and
+                                 (payload.photon_energy <
+                                  species_mass * (gamma - ONE) *
+                                    static_cast<real_t>(0.2));
+        random_pool.free_state(rand_gen);
+
+        return Kokkos::make_pair(
+          should_emit and (payload.photon_energy >= emitted_photon_min_energy),
+          should_drag and should_emit);
+      }
+
+      Inline void emit(const tuple_t<int, M::Dim>&      xi_Cd,
+                       const tuple_t<prtldx_t, M::Dim>& dxi_Cd,
+                       const vec_t<Dim::_3D>&           direction,
+                       real_t                           weight,
+                       real_t                           phi,
+                       const Payload&                   payload) const {
+        const auto index = Kokkos::atomic_fetch_add(&photon_idx(), 1);
+        if (not photon_use_tracking) {
+          kernel::InjectParticle<M::Dim, M::CoordType, false>(
+            photon_offset + index,
+            photon_i1,
+            photon_i2,
+            photon_i3,
+            photon_dx1,
+            photon_dx2,
+            photon_dx3,
+            photon_ux1,
+            photon_ux2,
+            photon_ux3,
+            photon_phi,
+            photon_weight,
+            photon_tag,
+            photon_pld_i,
+            xi_Cd,
+            dxi_Cd,
+            { direction[0] * payload.photon_energy,
+              direction[1] * payload.photon_energy,
+              direction[2] * payload.photon_energy },
+            emitted_photon_weight * weight,
+            phi);
+        } else {
+          kernel::InjectParticle<M::Dim, M::CoordType, true>(
+            photon_offset + index,
+            photon_i1,
+            photon_i2,
+            photon_i3,
+            photon_dx1,
+            photon_dx2,
+            photon_dx3,
+            photon_ux1,
+            photon_ux2,
+            photon_ux3,
+            photon_phi,
+            photon_weight,
+            photon_tag,
+            photon_pld_i,
+            xi_Cd,
+            dxi_Cd,
+            { direction[0] * payload.photon_energy,
+              direction[1] * payload.photon_energy,
+              direction[2] * payload.photon_energy },
+            emitted_photon_weight * weight,
+            phi,
+            domain_idx,
+            photon_cntr + index);
+        }
+      }
+    };
+
+  } // namespace emission
+} // namespace kernel
+
+#endif // KERNELS_EMISSION_SYNCHROTRON_HPP
diff --git a/src/kernels/faraday_gr.hpp b/src/kernels/faraday_gr.hpp
index b79afa460..110a7b1c4 100644
--- a/src/kernels/faraday_gr.hpp
+++ b/src/kernels/faraday_gr.hpp
@@ -19,6 +19,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::gr {
   using namespace ntt;
 
@@ -28,8 +30,9 @@ namespace kernel::gr {
    * @tparam M Metric
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M>
   class Faraday_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     const ndfield_t<D, 6> Bin;
diff --git a/src/kernels/faraday_sr.hpp b/src/kernels/faraday_sr.hpp
index be3e60dd0..bb7187c1b 100644
--- a/src/kernels/faraday_sr.hpp
+++ b/src/kernels/faraday_sr.hpp
@@ -19,6 +19,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::sr {
   using namespace ntt;
 
@@ -27,8 +29,9 @@ namespace kernel::sr {
    * space (diagonal metric)
    */
   template <class M>
+    requires metric::traits::HasD<M> && metric::traits::HasH_ij<M> &&
+             metric::traits::HasSqrtDetH<M>
   class Faraday_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     ndfield_t<D, 6> EB;
diff --git a/src/kernels/fields_bcs.hpp b/src/kernels/fields_bcs.hpp
index 575bda879..9deb97165 100644
--- a/src/kernels/fields_bcs.hpp
+++ b/src/kernels/fields_bcs.hpp
@@ -24,6 +24,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel::bc {
   using namespace ntt;
 
@@ -38,27 +40,44 @@ namespace kernel::bc {
    * @note It is supposed to only be called on the active side of the absorbing edge (so sign is not needed).
    */
   template <SimEngine::type S, class I, class M, in o>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert_i<M> &&
+             metric::traits::HasConvert<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransform_i<M>) ||
+              S == SimEngine::GRPIC) &&
+             (S == SimEngine::SRPIC &&
+                (::traits::fieldsetter::HasEx1<I, M::Dim> ||
+                 ::traits::fieldsetter::HasEx2<I, M::Dim> ||
+                 ::traits::fieldsetter::HasEx3<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx1<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx2<I, M::Dim> ||
+                 ::traits::fieldsetter::HasBx3<I, M::Dim>) ||
+              (S == SimEngine::GRPIC &&
+                 (::traits::fieldsetter::HasDx1<I, M::Dim> ||
+                  ::traits::fieldsetter::HasDx2<I, M::Dim> ||
+                  ::traits::fieldsetter::HasDx3<I, M::Dim>) ||
+               ::traits::fieldsetter::HasBx1<I, M::Dim> ||
+               ::traits::fieldsetter::HasBx2<I, M::Dim> ||
+               ::traits::fieldsetter::HasBx3<I, M::Dim>))
   struct MatchBoundaries_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static_assert(static_cast<dim_t>(o) < static_cast<dim_t>(M::Dim),
                   "Invalid component index");
     static constexpr auto  D = M::Dim;
     static constexpr idx_t i = static_cast<idx_t>(o) + 1u;
-    static constexpr bool defines_dx1 = traits::has_method<traits::dx1_t, I>::value;
-    static constexpr bool defines_dx2 = traits::has_method<traits::dx2_t, I>::value;
-    static constexpr bool defines_dx3 = traits::has_method<traits::dx3_t, I>::value;
-    static constexpr bool defines_ex1 = traits::has_method<traits::ex1_t, I>::value;
-    static constexpr bool defines_ex2 = traits::has_method<traits::ex2_t, I>::value;
-    static constexpr bool defines_ex3 = traits::has_method<traits::ex3_t, I>::value;
-    static constexpr bool defines_bx1 = traits::has_method<traits::bx1_t, I>::value;
-    static constexpr bool defines_bx2 = traits::has_method<traits::bx2_t, I>::value;
-    static constexpr bool defines_bx3 = traits::has_method<traits::bx3_t, I>::value;
-    static_assert(
-      (S == SimEngine::SRPIC and (defines_ex1 or defines_ex2 or defines_ex3 or
-                                  defines_bx1 or defines_bx2 or defines_bx3)) or
-        ((S == SimEngine::GRPIC) and (defines_dx1 or defines_dx2 or defines_dx3 or
-                                      defines_bx1 or defines_bx2 or defines_bx3)),
-      "none of the components of E/D or B are specified in PGEN");
+    // static constexpr bool defines_dx1 = traits::has_method<traits::dx1_t, I>::value;
+    // static constexpr bool defines_dx2 = traits::has_method<traits::dx2_t, I>::value;
+    // static constexpr bool defines_dx3 = traits::has_method<traits::dx3_t, I>::value;
+    // static constexpr bool defines_ex1 = traits::has_method<traits::ex1_t, I>::value;
+    // static constexpr bool defines_ex2 = traits::has_method<traits::ex2_t, I>::value;
+    // static constexpr bool defines_ex3 = traits::has_method<traits::ex3_t, I>::value;
+    // static constexpr bool defines_bx1 = traits::has_method<traits::bx1_t, I>::value;
+    // static constexpr bool defines_bx2 = traits::has_method<traits::bx2_t, I>::value;
+    // static constexpr bool defines_bx3 = traits::has_method<traits::bx3_t, I>::value;
+    // static_assert(
+    //   (S == SimEngine::SRPIC and (defines_ex1 or defines_ex2 or defines_ex3 or
+    //                               defines_bx1 or defines_bx2 or defines_bx3)) or
+    //     ((S == SimEngine::GRPIC) and (defines_dx1 or defines_dx2 or defines_dx3 or
+    //                                   defines_bx1 or defines_bx2 or defines_bx3)),
+    //   "none of the components of E/D or B are specified in PGEN");
 
     ndfield_t<M::Dim, 6> Fld;
     const I              fset;
@@ -106,10 +125,12 @@ namespace kernel::bc {
           metric.template convert<Crd::Cd, Crd::Ph>({ i1_ }, x_Ph_0);
           metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF }, x_Ph_H);
 
-          if constexpr (defines_ex1 or defines_bx2 or defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_1D> or
+                        ::traits::fieldsetter::HasBx2<I, Dim::_1D> or
+                        ::traits::fieldsetter::HasBx3<I, Dim::_1D>) {
             const auto s = shape(math::abs(
               metric.template convert<i, Crd::Cd, Crd::Ph>(i1_ + HALF) - xg_edge));
-            if constexpr (defines_ex1) {
+            if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_1D>) {
               if (tags & BC::E) {
                 Fld(i1, em::ex1) = s * Fld(i1, em::ex1) +
                                    (ONE - s) *
@@ -118,16 +139,18 @@ namespace kernel::bc {
                                        fset.ex1(x_Ph_H));
               }
             }
-            if constexpr (defines_bx2 or defines_bx3) {
+            // if constexpr (defines_bx2 or defines_bx3) {
+            if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_1D> or
+                          ::traits::fieldsetter::HasBx3<I, Dim::_1D>) {
               if (tags & BC::B) {
-                if constexpr (defines_bx2) {
+                if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_1D>) {
                   Fld(i1, em::bx2) = s * Fld(i1, em::bx2) +
                                      (ONE - s) *
                                        metric.template transform<2, Idx::T, Idx::U>(
                                          { i1_ + HALF },
                                          fset.bx2(x_Ph_H));
                 }
-                if constexpr (defines_bx3) {
+                if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_1D>) {
                   Fld(i1, em::bx3) = s * Fld(i1, em::bx3) +
                                      (ONE - s) *
                                        metric.template transform<3, Idx::T, Idx::U>(
@@ -137,10 +160,12 @@ namespace kernel::bc {
               }
             }
           }
-          if constexpr (defines_bx1 or defines_ex2 or defines_ex3) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_1D> or
+                        ::traits::fieldsetter::HasEx2<I, Dim::_1D> or
+                        ::traits::fieldsetter::HasEx3<I, Dim::_1D>) {
             const auto s = shape(math::abs(
               metric.template convert<i, Crd::Cd, Crd::Ph>(i1_) - xg_edge));
-            if constexpr (defines_bx1) {
+            if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_1D>) {
               if (tags & BC::B) {
                 Fld(i1, em::bx1) = s * Fld(i1, em::bx1) +
                                    (ONE - s) *
@@ -149,16 +174,18 @@ namespace kernel::bc {
                                        fset.bx1(x_Ph_0));
               }
             }
-            if constexpr (defines_ex2 or defines_ex3) {
+            // if constexpr (defines_ex2 or defines_ex3) {
+            if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_1D> or
+                          ::traits::fieldsetter::HasEx3<I, Dim::_1D>) {
               if (tags & BC::E) {
-                if constexpr (defines_ex2) {
+                if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_1D>) {
                   Fld(i1, em::ex2) = s * Fld(i1, em::ex2) +
                                      (ONE - s) *
                                        metric.template transform<2, Idx::T, Idx::U>(
                                          { i1_ },
                                          fset.ex2(x_Ph_0));
                 }
-                if constexpr (defines_ex3) {
+                if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_1D>) {
                   Fld(i1, em::ex3) = s * Fld(i1, em::ex3) +
                                      (ONE - s) *
                                        metric.template transform<3, Idx::T, Idx::U>(
@@ -185,7 +212,9 @@ namespace kernel::bc {
         const auto i2_ = COORD(i2);
 
         // SRPIC
-        if constexpr (defines_ex1 or defines_dx1 or defines_bx2) {
+        if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_2D> or
+                      ::traits::fieldsetter::HasDx1<I, Dim::_2D> or
+                      ::traits::fieldsetter::HasBx2<I, Dim::_2D>) {
           // i1 + 1/2, i2
           real_t xi_Cd;
           if constexpr (o == in::x1) {
@@ -200,22 +229,25 @@ namespace kernel::bc {
           coord_t<Dim::_2D> x_Ph_H0 { ZERO };
           metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ }, x_Ph_H0);
 
-          if constexpr (defines_ex1 or defines_dx1) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_2D> or
+                        ::traits::fieldsetter::HasDx1<I, Dim::_2D>) {
             if ((tags & BC::E) or (tags & BC::D)) {
-              if constexpr (defines_ex1 and S == SimEngine::SRPIC) {
+              if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_2D> and
+                            S == SimEngine::SRPIC) {
                 Fld(i1, i2, em::ex1) = s * Fld(i1, i2, em::ex1) +
                                        (ONE - s) *
                                          metric.template transform<1, Idx::T, Idx::U>(
                                            { i1_ + HALF, i2_ },
                                            fset.ex1(x_Ph_H0));
-              } else if constexpr (defines_dx1 and S == SimEngine::GRPIC) {
+              } else if constexpr (::traits::fieldsetter::HasDx1<I, Dim::_2D> and
+                                   S == SimEngine::GRPIC) {
                 Fld(i1, i2, em::dx1) = s * Fld(i1, i2, em::dx1) +
                                        (ONE - s) * fset.dx1(x_Ph_H0);
               }
             }
           }
 
-          if constexpr (defines_bx2) {
+          if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_2D>) {
             if (tags & BC::B) {
               if constexpr (S == SimEngine::SRPIC) {
                 Fld(i1, i2, em::bx2) = s * Fld(i1, i2, em::bx2) +
@@ -231,7 +263,9 @@ namespace kernel::bc {
           }
         }
 
-        if constexpr (defines_ex2 or defines_dx2 or defines_bx1) {
+        if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_2D> or
+                      ::traits::fieldsetter::HasDx2<I, Dim::_2D> or
+                      ::traits::fieldsetter::HasBx1<I, Dim::_2D>) {
           // i1, i2 + 1/2
           real_t xi_Cd;
           if constexpr (o == in::x1) {
@@ -246,22 +280,25 @@ namespace kernel::bc {
           coord_t<Dim::_2D> x_Ph_0H { ZERO };
           metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ + HALF }, x_Ph_0H);
 
-          if constexpr (defines_ex2 or defines_dx2) {
+          if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_2D> or
+                        ::traits::fieldsetter::HasDx2<I, Dim::_2D>) {
             if ((tags & BC::E) or (tags & BC::D)) {
-              if constexpr (defines_ex2 and S == SimEngine::SRPIC) {
+              if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_2D> and
+                            S == SimEngine::SRPIC) {
                 Fld(i1, i2, em::ex2) = s * Fld(i1, i2, em::ex2) +
                                        (ONE - s) *
                                          metric.template transform<2, Idx::T, Idx::U>(
                                            { i1_, i2_ + HALF },
                                            fset.ex2(x_Ph_0H));
-              } else if constexpr (defines_dx2 and S == SimEngine::GRPIC) {
+              } else if constexpr (::traits::fieldsetter::HasDx2<I, Dim::_2D> and
+                                   S == SimEngine::GRPIC) {
                 Fld(i1, i2, em::dx2) = s * Fld(i1, i2, em::dx2) +
                                        (ONE - s) * fset.dx2(x_Ph_0H);
               }
             }
           }
 
-          if constexpr (defines_bx1) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_2D>) {
             if (tags & BC::B) {
               if constexpr (S == SimEngine::SRPIC) {
                 Fld(i1, i2, em::bx1) = s * Fld(i1, i2, em::bx1) +
@@ -277,7 +314,9 @@ namespace kernel::bc {
           }
         }
 
-        if constexpr (defines_ex3 or defines_dx3) {
+        // if constexpr (defines_ex3 or defines_dx3) {
+        if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_2D> or
+                      ::traits::fieldsetter::HasDx3<I, Dim::_2D>) {
           if (tags & BC::E) {
             // i1, i2
             real_t xi_Cd;
@@ -293,7 +332,8 @@ namespace kernel::bc {
             coord_t<Dim::_2D> x_Ph_00 { ZERO };
             metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ }, x_Ph_00);
 
-            if constexpr (defines_ex3 and S == SimEngine::SRPIC) {
+            if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_2D> and
+                          S == SimEngine::SRPIC) {
               Fld(i1, i2, em::ex3) = s * Fld(i1, i2, em::ex3);
               if ((!is_axis_i2min or (i2 > N_GHOSTS)) and
                   (!is_axis_i2max or (i2 < extent_2 - N_GHOSTS))) {
@@ -302,7 +342,8 @@ namespace kernel::bc {
                                           { i1_, i2_ },
                                           fset.ex3(x_Ph_00));
               }
-            } else if constexpr (defines_dx3 and S == SimEngine::GRPIC) {
+            } else if constexpr (::traits::fieldsetter::HasDx3<I, Dim::_2D> and
+                                 S == SimEngine::GRPIC) {
               Fld(i1, i2, em::dx3) = s * Fld(i1, i2, em::dx3);
               if ((!is_axis_i2min or (i2 > N_GHOSTS)) and
                   (!is_axis_i2max or (i2 < extent_2 - N_GHOSTS))) {
@@ -312,7 +353,7 @@ namespace kernel::bc {
           }
         }
 
-        if constexpr (defines_bx3) {
+        if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_2D>) {
           if (tags & BC::B) {
             // i1 + 1/2, i2 + 1/2
             real_t xi_Cd;
@@ -356,9 +397,11 @@ namespace kernel::bc {
 
         if constexpr (S == SimEngine::SRPIC) {
           // SRPIC
-          if constexpr (defines_ex1 or defines_ex2 or defines_ex3) {
+          if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_3D> or
+                        ::traits::fieldsetter::HasEx2<I, Dim::_3D> or
+                        ::traits::fieldsetter::HasEx3<I, Dim::_3D>) {
             if (tags & BC::E) {
-              if constexpr (defines_ex1) {
+              if constexpr (::traits::fieldsetter::HasEx1<I, Dim::_3D>) {
                 // i1 + 1/2, i2, i3
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -382,7 +425,7 @@ namespace kernel::bc {
                                 fset.ex1(x_Ph_H00));
               }
 
-              if constexpr (defines_ex2) {
+              if constexpr (::traits::fieldsetter::HasEx2<I, Dim::_3D>) {
                 // i1, i2 + 1/2, i3
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -406,7 +449,7 @@ namespace kernel::bc {
                                 fset.ex2(x_Ph_0H0));
               }
 
-              if constexpr (defines_ex3) {
+              if constexpr (::traits::fieldsetter::HasEx3<I, Dim::_3D>) {
                 // i1, i2, i3 + 1/2
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -434,9 +477,11 @@ namespace kernel::bc {
             }
           }
 
-          if constexpr (defines_bx1 or defines_bx2 or defines_bx3) {
+          if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_3D> or
+                        ::traits::fieldsetter::HasBx2<I, Dim::_3D> or
+                        ::traits::fieldsetter::HasBx3<I, Dim::_3D>) {
             if (tags & BC::B) {
-              if constexpr (defines_bx1) {
+              if constexpr (::traits::fieldsetter::HasBx1<I, Dim::_3D>) {
                 // i1, i2 + 1/2, i3 + 1/2
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -461,7 +506,7 @@ namespace kernel::bc {
                                 fset.bx1(x_Ph_0HH));
               }
 
-              if constexpr (defines_bx2) {
+              if constexpr (::traits::fieldsetter::HasBx2<I, Dim::_3D>) {
                 // i1 + 1/2, i2, i3 + 1/2
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -486,7 +531,7 @@ namespace kernel::bc {
                                 fset.bx2(x_Ph_H0H));
               }
 
-              if constexpr (defines_bx3) {
+              if constexpr (::traits::fieldsetter::HasBx3<I, Dim::_3D>) {
                 // i1 + 1/2, i2 + 1/2, i3
                 real_t xi_Cd;
                 if constexpr (o == in::x1) {
@@ -925,21 +970,17 @@ namespace kernel::bc {
   // };
 
   template <class I, class M, bool P, in O>
+    requires metric::traits::HasD<M> && metric::traits::HasTransform_i<M> &&
+             metric::traits::HasConvert<M> &&
+             (static_cast<dim_t>(O) < static_cast<dim_t>(M::Dim)) &&
+             (::traits::fieldsetter::HasEx1<I, M::Dim> ||
+              ::traits::fieldsetter::HasEx2<I, M::Dim> ||
+              ::traits::fieldsetter::HasEx3<I, M::Dim> ||
+              ::traits::fieldsetter::HasBx1<I, M::Dim> ||
+              ::traits::fieldsetter::HasBx2<I, M::Dim> ||
+              ::traits::fieldsetter::HasBx3<I, M::Dim>)
   struct EnforcedBoundaries_kernel {
     static constexpr Dimension D = M::Dim;
-    static constexpr bool defines_ex1 = traits::has_method<traits::ex1_t, I>::value;
-    static constexpr bool defines_ex2 = traits::has_method<traits::ex2_t, I>::value;
-    static constexpr bool defines_ex3 = traits::has_method<traits::ex3_t, I>::value;
-    static constexpr bool defines_bx1 = traits::has_method<traits::bx1_t, I>::value;
-    static constexpr bool defines_bx2 = traits::has_method<traits::bx2_t, I>::value;
-    static constexpr bool defines_bx3 = traits::has_method<traits::bx3_t, I>::value;
-
-    static_assert(defines_ex1 or defines_ex2 or defines_ex3 or defines_bx1 or
-                    defines_bx2 or defines_bx3,
-                  "none of the components of E or B are specified in PGEN");
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(static_cast<dim_t>(O) < static_cast<dim_t>(M::Dim),
-                  "Invalid Orientation");
 
     ndfield_t<D, 6> Fld;
     const I         fset;
@@ -965,12 +1006,12 @@ namespace kernel::bc {
         coord_t<Dim::_1D> x_Ph_H { ZERO };
         metric.template convert<Crd::Cd, Crd::Ph>({ i1_ }, x_Ph_0);
         metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF }, x_Ph_H);
-        bool setEx1 = defines_ex1 and (tags & BC::E),
-             setEx2 = defines_ex2 and (tags & BC::E),
-             setEx3 = defines_ex3 and (tags & BC::E),
-             setBx1 = defines_bx1 and (tags & BC::B),
-             setBx2 = defines_bx2 and (tags & BC::B),
-             setBx3 = defines_bx3 and (tags & BC::B);
+        bool setEx1 = ::traits::fieldsetter::HasEx1<I, M::Dim> and (tags & BC::E),
+             setEx2 = ::traits::fieldsetter::HasEx2<I, M::Dim> and (tags & BC::E),
+             setEx3 = ::traits::fieldsetter::HasEx3<I, M::Dim> and (tags & BC::E),
+             setBx1 = ::traits::fieldsetter::HasBx1<I, M::Dim> and (tags & BC::B),
+             setBx2 = ::traits::fieldsetter::HasBx2<I, M::Dim> and (tags & BC::B),
+             setBx3 = ::traits::fieldsetter::HasBx3<I, M::Dim> and (tags & BC::B);
         if constexpr (O == in::x1) {
           // x1 -- normal
           // x2,x3 -- tangential
@@ -986,42 +1027,42 @@ namespace kernel::bc {
         } else {
           raise::KernelError(HERE, "Invalid Orientation");
         }
-        if constexpr (defines_ex1) {
+        if constexpr (::traits::fieldsetter::HasEx1<I, M::Dim>) {
           if (setEx1) {
             Fld(i1, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF },
               fset.ex1(x_Ph_H));
           }
         }
-        if constexpr (defines_ex2) {
+        if constexpr (::traits::fieldsetter::HasEx2<I, M::Dim>) {
           if (setEx2) {
             Fld(i1, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ },
               fset.ex2(x_Ph_0));
           }
         }
-        if constexpr (defines_ex3) {
+        if constexpr (::traits::fieldsetter::HasEx3<I, M::Dim>) {
           if (setEx3) {
             Fld(i1, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ },
               fset.ex3(x_Ph_0));
           }
         }
-        if constexpr (defines_bx1) {
+        if constexpr (::traits::fieldsetter::HasBx1<I, M::Dim>) {
           if (setBx1) {
             Fld(i1, em::bx1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ },
               fset.bx1(x_Ph_0));
           }
         }
-        if constexpr (defines_bx2) {
+        if constexpr (::traits::fieldsetter::HasBx2<I, M::Dim>) {
           if (setBx2) {
             Fld(i1, em::bx2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ + HALF },
               fset.bx2(x_Ph_H));
           }
         }
-        if constexpr (defines_bx3) {
+        if constexpr (::traits::fieldsetter::HasBx3<I, M::Dim>) {
           if (setBx3) {
             Fld(i1, em::bx3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ + HALF },
@@ -1046,12 +1087,13 @@ namespace kernel::bc {
         metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ }, x_Ph_H0);
         metric.template convert<Crd::Cd, Crd::Ph>({ i1_ + HALF, i2_ + HALF },
                                                   x_Ph_HH);
-        bool setEx1 = defines_ex1 and (tags & BC::E),
-             setEx2 = defines_ex2 and (tags & BC::E),
-             setEx3 = defines_ex3 and (tags & BC::E),
-             setBx1 = defines_bx1 and (tags & BC::B),
-             setBx2 = defines_bx2 and (tags & BC::B),
-             setBx3 = defines_bx3 and (tags & BC::B);
+        bool setEx1 = ::traits::fieldsetter::HasEx1<I, M::Dim> and (tags & BC::E),
+             setEx2 = ::traits::fieldsetter::HasEx2<I, M::Dim> and (tags & BC::E),
+             setEx3 = ::traits::fieldsetter::HasEx3<I, M::Dim> and (tags & BC::E),
+             setBx1 = ::traits::fieldsetter::HasBx1<I, M::Dim> and (tags & BC::B),
+             setBx2 = ::traits::fieldsetter::HasBx2<I, M::Dim> and (tags & BC::B),
+             setBx3 = ::traits::fieldsetter::HasBx3<I, M::Dim> and (tags & BC::B);
+
         if constexpr (O == in::x1) {
           // x1 -- normal
           // x2,x3 -- tangential
@@ -1079,42 +1121,42 @@ namespace kernel::bc {
         } else {
           raise::KernelError(HERE, "Invalid Orientation");
         }
-        if constexpr (defines_ex1) {
+        if constexpr (::traits::fieldsetter::HasEx1<I, M::Dim>) {
           if (setEx1) {
             Fld(i1, i2, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ },
               fset.ex1(x_Ph_H0));
           }
         }
-        if constexpr (defines_ex2) {
+        if constexpr (::traits::fieldsetter::HasEx2<I, M::Dim>) {
           if (setEx2) {
             Fld(i1, i2, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_, i2_ + HALF },
               fset.ex2(x_Ph_0H));
           }
         }
-        if constexpr (defines_ex3) {
+        if constexpr (::traits::fieldsetter::HasEx3<I, M::Dim>) {
           if (setEx3) {
             Fld(i1, i2, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_, i2_ },
               fset.ex3(x_Ph_00));
           }
         }
-        if constexpr (defines_bx1) {
+        if constexpr (::traits::fieldsetter::HasBx1<I, M::Dim>) {
           if (setBx1) {
             Fld(i1, i2, em::bx1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_, i2_ + HALF },
               fset.bx1(x_Ph_0H));
           }
         }
-        if constexpr (defines_bx2) {
+        if constexpr (::traits::fieldsetter::HasBx2<I, M::Dim>) {
           if (setBx2) {
             Fld(i1, i2, em::bx2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ },
               fset.bx2(x_Ph_H0));
           }
         }
-        if constexpr (defines_bx3) {
+        if constexpr (::traits::fieldsetter::HasBx3<I, M::Dim>) {
           if (setBx3) {
             Fld(i1, i2, em::bx3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ + HALF },
@@ -1150,12 +1192,12 @@ namespace kernel::bc {
                                                   x_Ph_H0H);
         metric.template convert<Crd::Cd, Crd::Ph>({ i1_, i2_ + HALF, i3_ + HALF },
                                                   x_Ph_0HH);
-        bool setEx1 = defines_ex1 and (tags & BC::E),
-             setEx2 = defines_ex2 and (tags & BC::E),
-             setEx3 = defines_ex3 and (tags & BC::E),
-             setBx1 = defines_bx1 and (tags & BC::B),
-             setBx2 = defines_bx2 and (tags & BC::B),
-             setBx3 = defines_bx3 and (tags & BC::B);
+        bool setEx1 = ::traits::fieldsetter::HasEx1<I, M::Dim> and (tags & BC::E),
+             setEx2 = ::traits::fieldsetter::HasEx2<I, M::Dim> and (tags & BC::E),
+             setEx3 = ::traits::fieldsetter::HasEx3<I, M::Dim> and (tags & BC::E),
+             setBx1 = ::traits::fieldsetter::HasBx1<I, M::Dim> and (tags & BC::B),
+             setBx2 = ::traits::fieldsetter::HasBx2<I, M::Dim> and (tags & BC::B),
+             setBx3 = ::traits::fieldsetter::HasBx3<I, M::Dim> and (tags & BC::B);
         if constexpr (O == in::x1) {
           // x1 -- normal
           // x2,x3 -- tangential
@@ -1195,42 +1237,42 @@ namespace kernel::bc {
         } else {
           raise::KernelError(HERE, "Invalid Orientation");
         }
-        if constexpr (defines_ex1) {
+        if constexpr (::traits::fieldsetter::HasEx1<I, M::Dim>) {
           if (setEx1) {
             Fld(i1, i2, i3, em::ex1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_ + HALF, i2_, i3_ },
               fset.ex1(x_Ph_H00));
           }
         }
-        if constexpr (defines_ex2) {
+        if constexpr (::traits::fieldsetter::HasEx2<I, M::Dim>) {
           if (setEx2) {
             Fld(i1, i2, i3, em::ex2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_, i2_ + HALF, i3_ },
               fset.ex2(x_Ph_0H0));
           }
         }
-        if constexpr (defines_ex3) {
+        if constexpr (::traits::fieldsetter::HasEx3<I, M::Dim>) {
           if (setEx3) {
             Fld(i1, i2, i3, em::ex3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_, i2_, i3_ + HALF },
               fset.ex3(x_Ph_00H));
           }
         }
-        if constexpr (defines_bx1) {
+        if constexpr (::traits::fieldsetter::HasBx1<I, M::Dim>) {
           if (setBx1) {
             Fld(i1, i2, i3, em::bx1) = metric.template transform<1, Idx::T, Idx::U>(
               { i1_, i2_ + HALF, i3_ + HALF },
               fset.bx1(x_Ph_0HH));
           }
         }
-        if constexpr (defines_bx2) {
+        if constexpr (::traits::fieldsetter::HasBx2<I, M::Dim>) {
           if (setBx2) {
             Fld(i1, i2, i3, em::bx2) = metric.template transform<2, Idx::T, Idx::U>(
               { i1_ + HALF, i2_, i3_ + HALF },
               fset.bx2(x_Ph_H0H));
           }
         }
-        if constexpr (defines_bx3) {
+        if constexpr (::traits::fieldsetter::HasBx3<I, M::Dim>) {
           if (setBx3) {
             Fld(i1, i2, i3, em::bx3) = metric.template transform<3, Idx::T, Idx::U>(
               { i1_ + HALF, i2_ + HALF, i3_ },
@@ -1245,17 +1287,17 @@ namespace kernel::bc {
 
   namespace gr {
 
-    template <class M>
+    template <Dimension D>
     struct HorizonBoundaries_kernel {
-      ndfield_t<M::Dim, 6> Fld;
-      const std::size_t    i1_min;
-      const bool           setE, setB;
-      const std::size_t    nfilter;
-
-      HorizonBoundaries_kernel(ndfield_t<M::Dim, 6> Fld,
-                               std::size_t          i1_min,
-                               BCTags               tags,
-                               std::size_t          nfilter)
+      ndfield_t<D, 6>   Fld;
+      const std::size_t i1_min;
+      const bool        setE, setB;
+      const std::size_t nfilter;
+
+      HorizonBoundaries_kernel(ndfield_t<D, 6> Fld,
+                               std::size_t     i1_min,
+                               BCTags          tags,
+                               std::size_t     nfilter)
         : Fld { Fld }
         , i1_min { i1_min }
         , setE { (tags & BC::Ex1 or tags & BC::Ex2 or tags & BC::Ex3) or
@@ -1265,7 +1307,7 @@ namespace kernel::bc {
         , nfilter { nfilter } {}
 
       Inline void operator()(index_t i2) const {
-        if constexpr (M::Dim == Dim::_2D) {
+        if constexpr (D == Dim::_2D) {
           if (setE) {
             for (unsigned short i = 0; i <= 2 + nfilter; ++i) {
               Fld(i1_min - N_GHOSTS + i,
@@ -1301,8 +1343,8 @@ namespace kernel::bc {
     };
 
     template <class M, idx_t i>
+      requires metric::traits::HasD<M> && metric::traits::HasConvert_i<M>
     struct AbsorbCurrents_kernel {
-      static_assert(M::is_metric, "M must be a metric class");
       static_assert(i <= static_cast<unsigned short>(M::Dim),
                     "Invalid component index");
 
diff --git a/src/kernels/fields_to_phys.hpp b/src/kernels/fields_to_phys.hpp
index a44a7b30d..6d402b15a 100644
--- a/src/kernels/fields_to_phys.hpp
+++ b/src/kernels/fields_to_phys.hpp
@@ -27,14 +27,15 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel {
   using namespace ntt;
 
   template <class M, int N1, int N2>
+    requires metric::traits::HasD<M> && metric::traits::HasTransform<M> &&
+             (N1 >= 3) && (N2 >= 3)
   class FieldsToPhys_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(N1 >= 3 && N2 >= 3, "Invalid N1 and/or N2");
-
     static constexpr auto D = M::Dim;
 
     const ndfield_t<D, N1>   Ffrom;
diff --git a/src/kernels/injectors.hpp b/src/kernels/injectors.hpp
index cddb18839..2f9e6a3e4 100644
--- a/src/kernels/injectors.hpp
+++ b/src/kernels/injectors.hpp
@@ -19,6 +19,9 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
+#include "archetypes/traits.h"
 #include "framework/containers/particles.h"
 #include "framework/domain/domain.h"
 
@@ -76,10 +79,12 @@ namespace kernel {
   }
 
   template <SimEngine::type S, class M, class ED1, class ED2>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasTransform<M>)) &&
+             arch::traits::energydist::IsValid<ED1> &&
+             arch::traits::energydist::IsValid<ED2>
   struct UniformInjector_kernel {
-    static_assert(ED1::is_energy_dist, "ED1 must be an energy distribution class");
-    static_assert(ED2::is_energy_dist, "ED2 must be an energy distribution class");
-    static_assert(M::is_metric, "M must be a metric class");
 
     array_t<int*>      i1s_1, i2s_1, i3s_1;
     array_t<prtldx_t*> dx1s_1, dx2s_1, dx3s_1;
@@ -291,8 +296,10 @@ namespace kernel {
   }; // struct UniformInjector_kernel
 
   template <SimEngine::type S, class M>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasTransform<M>))
   struct GlobalInjector_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     const bool use_weights;
@@ -522,11 +529,14 @@ namespace kernel {
   }; // struct GlobalInjector_kernel
 
   template <SimEngine::type S, class M, class ED1, class ED2, class SD>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert<M> &&
+             metric::traits::HasSqrtDetH<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasTransform<M>)) &&
+             arch::traits::energydist::IsValid<ED1> &&
+             arch::traits::energydist::IsValid<ED2> &&
+             arch::traits::spatialdist::IsValid<SD>
   struct NonUniformInjector_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(ED1::is_energy_dist, "ED1 must be an energy distribution class");
-    static_assert(ED2::is_energy_dist, "ED2 must be an energy distribution class");
-    static_assert(SD::is_spatial_dist, "SD must be a spatial distribution class");
 
     const real_t ppc0;
 
diff --git a/src/kernels/particle_moments.hpp b/src/kernels/particle_moments.hpp
index a2145fa89..023eb55a5 100644
--- a/src/kernels/particle_moments.hpp
+++ b/src/kernels/particle_moments.hpp
@@ -18,6 +18,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #include <vector>
 
 namespace kernel {
@@ -35,8 +37,10 @@ namespace kernel {
   }
 
   template <SimEngine::type S, class M, FldsID::type F, unsigned short N>
+    requires metric::traits::HasD<M> && metric::traits::HasSqrtDetH<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              (S == SimEngine::GRPIC && metric::traits::HasTransform<M>))
   class ParticleMoments_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
     static_assert(!((S == SimEngine::GRPIC) && (F == FldsID::V)),
diff --git a/src/kernels/particle_pusher_gr.hpp b/src/kernels/particle_pusher_gr.hpp
index 4432792ba..2c0d8eddd 100644
--- a/src/kernels/particle_pusher_gr.hpp
+++ b/src/kernels/particle_pusher_gr.hpp
@@ -21,6 +21,8 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 #if defined(MPI_ENABLED)
   #include "arch/mpi_tags.h"
 #endif
@@ -29,7 +31,9 @@
 /* Local macros                                                               */
 /* -------------------------------------------------------------------------- */
 #define from_Xi_to_i(XI, I)                                                    \
-  { I = static_cast<int>((XI + 1)) - 1; }
+  {                                                                            \
+    I = static_cast<int>((XI + 1)) - 1;                                        \
+  }
 
 #define from_Xi_to_i_di(XI, I, DI)                                             \
   {                                                                            \
@@ -56,13 +60,21 @@ namespace kernel::gr {
 
   struct Massless_t {};
 
+  template <class M>
+  concept IsCompatibleWithPusherGR = metric::traits::HasD<M> &&
+                                     metric::traits::HasTransform<M> &&
+                                     metric::traits::HasHij<M> &&
+                                     metric::traits::HasAlpha<M> &&
+                                     metric::traits::HasBeta1<M> &&
+                                     metric::traits::HasMetricDerivatives<M>;
+
   /**
    * @brief Algorithm for the Particle pusher
    * @tparam M Metric
    */
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   class Pusher_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
   private:
@@ -306,6 +318,7 @@ namespace kernel::gr {
   /* -------------------------------------------------------------------------- */
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   template <typename T>
   Inline void Pusher_kernel<M>::GeodesicMomentumPush(T,
                                                      const coord_t<D>&      xp,
@@ -379,6 +392,7 @@ namespace kernel::gr {
   }
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   template <typename T>
   Inline void Pusher_kernel<M>::GeodesicCoordinatePush(T,
                                                        const coord_t<D>& xp,
@@ -414,6 +428,7 @@ namespace kernel::gr {
   }
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   template <typename T>
   Inline void Pusher_kernel<M>::GeodesicFullPush(T,
                                                  const coord_t<D>&      xp,
@@ -488,6 +503,7 @@ namespace kernel::gr {
   /*                                 Phi pusher */
   /* -------------------------------------------------------------------------- */
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   template <typename T>
   Inline void Pusher_kernel<M>::UpdatePhi(T,
                                           const coord_t<D>&      xp,
@@ -511,6 +527,7 @@ namespace kernel::gr {
   }
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   Inline void Pusher_kernel<M>::interpolateFields(index_t          p,
                                                   vec_t<Dim::_3D>& e0,
                                                   vec_t<Dim::_3D>& b0) const {
@@ -591,6 +608,7 @@ namespace kernel::gr {
   /* ------------------------------ Photon pusher ----------------------------- */
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   Inline void Pusher_kernel<M>::operator()(Massless_t, index_t p) const {
     if constexpr (D == Dim::_1D) {
       raise::KernelError(HERE, "Photon pusher not implemented for 1D");
@@ -651,6 +669,7 @@ namespace kernel::gr {
   /* ------------------------- Massive particle pusher ------------------------ */
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   Inline void Pusher_kernel<M>::operator()(Massive_t, index_t p) const {
     if constexpr (D == Dim::_1D) {
       raise::KernelError(HERE, "Massive pusher not implemented for 1D");
@@ -743,6 +762,7 @@ namespace kernel::gr {
   // Boundary conditions
 
   template <class M>
+    requires IsCompatibleWithPusherGR<M>
   Inline void Pusher_kernel<M>::boundaryConditions(index_t p) const {
     if constexpr (D == Dim::_1D || D == Dim::_2D || D == Dim::_3D) {
       if (i1(p) < 0 && is_absorb_i1min) {
diff --git a/src/kernels/particle_pusher_sr.hpp b/src/kernels/particle_pusher_sr.hpp
index 232481450..d30cb73fc 100644
--- a/src/kernels/particle_pusher_sr.hpp
+++ b/src/kernels/particle_pusher_sr.hpp
@@ -3,6 +3,8 @@
  * @brief Particle pusher for the SR
  * @implements
  *   - kernel::sr::Pusher_kernel<>
+ *   - kernel::sr::PusherParams
+ *   - kernel::sr::PusherArrays
  * @namespaces:
  *   - kernel::sr::
  * @macros:
@@ -21,7 +23,11 @@
 #include "arch/kokkos_aliases.h"
 #include "utils/error.h"
 #include "utils/numeric.h"
+#include "utils/param_container.h"
 
+#include "metrics/traits.h"
+
+#include "kernels/emission/emission.hpp"
 #include "particle_shapes.hpp"
 
 #if defined(MPI_ENABLED)
@@ -32,7 +38,9 @@
 /* Local macros                                                               */
 /* -------------------------------------------------------------------------- */
 #define from_Xi_to_i(XI, I)                                                    \
-  { I = static_cast<int>((XI + 1)) - 1; }
+  {                                                                            \
+    I = static_cast<int>((XI + 1)) - 1;                                        \
+  }
 
 #define from_Xi_to_i_di(XI, I, DI)                                             \
   {                                                                            \
@@ -47,19 +55,7 @@
 namespace kernel::sr {
   using namespace ntt;
 
-  namespace Cooling {
-    enum CoolingTags_ {
-      None        = 0,
-      Synchrotron = 1 << 0,
-      Compton     = 1 << 1,
-    };
-  } // namespace Cooling
-
-  typedef int CoolingTags;
-
-  struct NoForce_t {
-    NoForce_t() {}
-  };
+  struct NoForce_t {};
 
   /**
    * @brief
@@ -75,8 +71,8 @@ namespace kernel::sr {
    */
   template <Dimension D, Coord::type C, class F = NoForce_t, bool Atm = false>
   struct Force {
-    static constexpr auto ExtForce = not std::is_same<F, NoForce_t>::value;
-    static_assert(ExtForce or Atm,
+    static constexpr auto HasExtForce = not std::is_same<F, NoForce_t>::value;
+    static_assert(HasExtForce or Atm,
                   "Force initialized with neither PGen force nor gravity");
 
     const F      pgen_force;
@@ -102,7 +98,7 @@ namespace kernel::sr {
 
     Force(const vec_t<Dim::_3D>& g, real_t x_surf, real_t ds)
       : Force { NoForce_t {}, g, x_surf, ds } {
-      raise::ErrorIf(ExtForce, "External force not provided", HERE);
+      raise::ErrorIf(HasExtForce, "External force not provided", HERE);
     }
 
     Inline auto fx1(spidx_t           sp,
@@ -110,7 +106,7 @@ namespace kernel::sr {
                     bool              ext_force,
                     const coord_t<D>& x_Ph) const -> real_t {
       real_t f_x1 = ZERO;
-      if constexpr (ExtForce) {
+      if constexpr (HasExtForce) {
         if (ext_force) {
           f_x1 += pgen_force.fx1(sp, time, x_Ph);
         }
@@ -136,7 +132,7 @@ namespace kernel::sr {
                     bool              ext_force,
                     const coord_t<D>& x_Ph) const -> real_t {
       real_t f_x2 = ZERO;
-      if constexpr (ExtForce) {
+      if constexpr (HasExtForce) {
         if (ext_force) {
           f_x2 += pgen_force.fx2(sp, time, x_Ph);
         }
@@ -162,7 +158,7 @@ namespace kernel::sr {
                     bool              ext_force,
                     const coord_t<D>& x_Ph) const -> real_t {
       real_t f_x3 = ZERO;
-      if constexpr (ExtForce) {
+      if constexpr (HasExtForce) {
         if (ext_force) {
           f_x3 += pgen_force.fx3(sp, time, x_Ph);
         }
@@ -184,230 +180,214 @@ namespace kernel::sr {
     }
   };
 
+  struct PusherParams {
+    // pusher algorithm(s) assigned to the species
+    ParticlePusherFlags pusher_flags { ParticlePusher::NONE };
+    // radiative drag force(s) enabled for the species
+    RadiativeDragFlags  radiative_drag_flags { RadiativeDrag::NONE };
+
+    // external force (other than the atmosphere)
+    bool ext_force { false };
+
+    // species parameters
+    float mass, charge;
+
+    // time variable
+    simtime_t time;
+
+    // global constants
+    real_t dt, omegaB0;
+
+    // grid parameters
+    int                  ni1, ni2, ni3;
+    boundaries_t<PrtlBC> boundaries;
+
+    // parameters for the advanced features
+    prm::Parameters gca_params;
+    prm::Parameters radiative_drag_params;
+  };
+
+  struct PusherArrays {
+    spidx_t            sp;
+    array_t<int*>      i1, i2, i3;
+    array_t<int*>      i1_prev, i2_prev, i3_prev;
+    array_t<prtldx_t*> dx1, dx2, dx3;
+    array_t<prtldx_t*> dx1_prev, dx2_prev, dx3_prev;
+    array_t<real_t*>   ux1, ux2, ux3;
+    array_t<real_t*>   phi;
+    array_t<real_t*>   weight;
+    array_t<short*>    tag;
+  };
+
   /**
    * @tparam M Metric
    * @tparam F Additional force
    */
-  template <class M, class F = NoForce_t>
+  template <class M, class F = NoForce_t, class E = NoEmissionPolicy_t<SimEngine::SRPIC, M>>
+    requires metric::traits::HasD<M> && metric::traits::HasTransformXYZ<M> &&
+             metric::traits::HasConvertXYZ<M> &&
+             metric::traits::HasTransform_i<M> && metric::traits::HasConvert_i<M>
   struct Pusher_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static constexpr auto D        = M::Dim;
-    static constexpr auto ExtForce = not std::is_same<F, NoForce_t>::value;
+    static constexpr auto D           = M::Dim;
+    static constexpr auto HasExtForce = not std::is_same<F, NoForce_t>::value;
+    static constexpr auto HasEmission =
+      not std::is_same<E, NoEmissionPolicy_t<SimEngine::SRPIC, M>>::value;
 
   private:
-    const PrtlPusher::type pusher;
-    const bool             GCA;
-    const bool             ext_force;
-    const CoolingTags      cooling;
+    const ParticlePusherFlags pusher_flags;
+    const RadiativeDragFlags  radiative_drag_flags;
+
+    const bool ext_force;
 
     const randacc_ndfield_t<D, 6> EB;
-    const spidx_t                 sp;
-    array_t<int*>                 i1, i2, i3;
-    array_t<int*>                 i1_prev, i2_prev, i3_prev;
-    array_t<prtldx_t*>            dx1, dx2, dx3;
-    array_t<prtldx_t*>            dx1_prev, dx2_prev, dx3_prev;
-    array_t<real_t*>              ux1, ux2, ux3;
-    array_t<real_t*>              phi;
-    array_t<short*>               tag;
-    const M                       metric;
-    const F                       force;
-
-    const real_t time, coeff, dt;
-    const int    ni1, ni2, ni3;
-    bool         is_absorb_i1min { false }, is_absorb_i1max { false };
-    bool         is_absorb_i2min { false }, is_absorb_i2max { false };
-    bool         is_absorb_i3min { false }, is_absorb_i3max { false };
-    bool         is_periodic_i1min { false }, is_periodic_i1max { false };
-    bool         is_periodic_i2min { false }, is_periodic_i2max { false };
-    bool         is_periodic_i3min { false }, is_periodic_i3max { false };
-    bool         is_reflect_i1min { false }, is_reflect_i1max { false };
-    bool         is_reflect_i2min { false }, is_reflect_i2max { false };
-    bool         is_reflect_i3min { false }, is_reflect_i3max { false };
-    bool         is_axis_i2min { false }, is_axis_i2max { false };
+
+    const spidx_t      sp;
+    array_t<int*>      i1, i2, i3;
+    array_t<int*>      i1_prev, i2_prev, i3_prev;
+    array_t<prtldx_t*> dx1, dx2, dx3;
+    array_t<prtldx_t*> dx1_prev, dx2_prev, dx3_prev;
+    array_t<real_t*>   ux1, ux2, ux3;
+    array_t<real_t*>   phi;
+    array_t<real_t*>   weight;
+    array_t<short*>    tag;
+    const M            metric;
+    const F            force;
+
+    const E emission_policy;
+
+    const simtime_t time;
+    const real_t    coeff, dt;
+
+    const int ni1, ni2, ni3;
+    bool      is_absorb_i1min { false }, is_absorb_i1max { false };
+    bool      is_absorb_i2min { false }, is_absorb_i2max { false };
+    bool      is_absorb_i3min { false }, is_absorb_i3max { false };
+    bool      is_periodic_i1min { false }, is_periodic_i1max { false };
+    bool      is_periodic_i2min { false }, is_periodic_i2max { false };
+    bool      is_periodic_i3min { false }, is_periodic_i3max { false };
+    bool      is_reflect_i1min { false }, is_reflect_i1max { false };
+    bool      is_reflect_i2min { false }, is_reflect_i2max { false };
+    bool      is_reflect_i3min { false }, is_reflect_i3max { false };
+    bool      is_axis_i2min { false }, is_axis_i2max { false };
+
     // gca parameters
     const real_t gca_larmor, gca_EovrB_sqr;
-    // radiative cooling parameters
-    const real_t coeff_sync, coeff_comp;
+    // radiative drag parameters
+    const real_t raddrag_coeff_synchrotron, raddrag_coeff_compton;
 
   public:
-    Pusher_kernel(const PrtlPusher::type&        pusher,
-                  bool                           GCA,
-                  bool                           ext_force,
-                  CoolingTags                    cooling,
-                  const randacc_ndfield_t<D, 6>& EB,
-                  spidx_t                        sp,
-                  array_t<int*>&                 i1,
-                  array_t<int*>&                 i2,
-                  array_t<int*>&                 i3,
-                  array_t<int*>&                 i1_prev,
-                  array_t<int*>&                 i2_prev,
-                  array_t<int*>&                 i3_prev,
-                  array_t<prtldx_t*>&            dx1,
-                  array_t<prtldx_t*>&            dx2,
-                  array_t<prtldx_t*>&            dx3,
-                  array_t<prtldx_t*>&            dx1_prev,
-                  array_t<prtldx_t*>&            dx2_prev,
-                  array_t<prtldx_t*>&            dx3_prev,
-                  array_t<real_t*>&              ux1,
-                  array_t<real_t*>&              ux2,
-                  array_t<real_t*>&              ux3,
-                  array_t<real_t*>&              phi,
-                  array_t<short*>&               tag,
-                  const M&                       metric,
-                  const F&                       force,
-                  real_t                         time,
-                  real_t                         coeff,
-                  real_t                         dt,
-                  int                            ni1,
-                  int                            ni2,
-                  int                            ni3,
-                  const boundaries_t<PrtlBC>&    boundaries,
-                  real_t                         gca_larmor_max,
-                  real_t                         gca_eovrb_max,
-                  real_t                         coeff_sync,
-                  real_t                         coeff_comp)
-      : pusher { pusher }
-      , GCA { GCA }
-      , ext_force { ext_force }
-      , cooling { cooling }
+    Pusher_kernel(
+      const PusherParams&            pusher_params,
+      PusherArrays&                  pusher_arrays,
+      const randacc_ndfield_t<D, 6>& EB,
+      const M&                       metric,
+      const F&                       force = NoForce_t {},
+      const E& emission_policy = NoEmissionPolicy_t<SimEngine::SRPIC, M> {})
+      : pusher_flags { pusher_params.pusher_flags }
+      , radiative_drag_flags { pusher_params.radiative_drag_flags }
+      , ext_force { pusher_params.ext_force }
       , EB { EB }
-      , sp { sp }
-      , i1 { i1 }
-      , i2 { i2 }
-      , i3 { i3 }
-      , i1_prev { i1_prev }
-      , i2_prev { i2_prev }
-      , i3_prev { i3_prev }
-      , dx1 { dx1 }
-      , dx2 { dx2 }
-      , dx3 { dx3 }
-      , dx1_prev { dx1_prev }
-      , dx2_prev { dx2_prev }
-      , dx3_prev { dx3_prev }
-      , ux1 { ux1 }
-      , ux2 { ux2 }
-      , ux3 { ux3 }
-      , phi { phi }
-      , tag { tag }
+      , sp { pusher_arrays.sp }
+      , i1 { pusher_arrays.i1 }
+      , i2 { pusher_arrays.i2 }
+      , i3 { pusher_arrays.i3 }
+      , i1_prev { pusher_arrays.i1_prev }
+      , i2_prev { pusher_arrays.i2_prev }
+      , i3_prev { pusher_arrays.i3_prev }
+      , dx1 { pusher_arrays.dx1 }
+      , dx2 { pusher_arrays.dx2 }
+      , dx3 { pusher_arrays.dx3 }
+      , dx1_prev { pusher_arrays.dx1_prev }
+      , dx2_prev { pusher_arrays.dx2_prev }
+      , dx3_prev { pusher_arrays.dx3_prev }
+      , ux1 { pusher_arrays.ux1 }
+      , ux2 { pusher_arrays.ux2 }
+      , ux3 { pusher_arrays.ux3 }
+      , phi { pusher_arrays.phi }
+      , weight { pusher_arrays.weight }
+      , tag { pusher_arrays.tag }
       , metric { metric }
       , force { force }
-      , time { time }
-      , coeff { coeff }
-      , dt { dt }
-      , ni1 { ni1 }
-      , ni2 { ni2 }
-      , ni3 { ni3 }
-      , gca_larmor { gca_larmor_max }
-      , gca_EovrB_sqr { SQR(gca_eovrb_max) }
-      , coeff_sync { coeff_sync }
-      , coeff_comp { coeff_comp } {
-      raise::ErrorIf(boundaries.size() < 1, "boundaries defined incorrectly", HERE);
-      is_absorb_i1min = (boundaries[0].first == PrtlBC::ATMOSPHERE) ||
-                        (boundaries[0].first == PrtlBC::ABSORB);
-      is_absorb_i1max = (boundaries[0].second == PrtlBC::ATMOSPHERE) ||
-                        (boundaries[0].second == PrtlBC::ABSORB);
-      is_periodic_i1min = (boundaries[0].first == PrtlBC::PERIODIC);
-      is_periodic_i1max = (boundaries[0].second == PrtlBC::PERIODIC);
-      is_reflect_i1min  = (boundaries[0].first == PrtlBC::REFLECT);
-      is_reflect_i1max  = (boundaries[0].second == PrtlBC::REFLECT);
+      , time { pusher_params.time }
+      , coeff { HALF * (pusher_params.charge / pusher_params.mass) *
+                pusher_params.omegaB0 * pusher_params.dt }
+      , dt { pusher_params.dt }
+      , ni1 { pusher_params.ni1 }
+      , ni2 { pusher_params.ni2 }
+      , ni3 { pusher_params.ni3 }
+      , gca_larmor { (pusher_flags & ParticlePusher::GCA)
+                       ? pusher_params.gca_params.get<real_t>("larmor_max")
+                       : ZERO }
+      , gca_EovrB_sqr { (pusher_flags & ParticlePusher::GCA)
+                          ? SQR(pusher_params.gca_params.get<real_t>(
+                              "e_ovr_b_max"))
+                          : ZERO }
+      , raddrag_coeff_synchrotron { ((pusher_params.radiative_drag_flags &
+                                      RadiativeDrag::SYNCHROTRON) and
+                                     (not HasEmission))
+                                      ? static_cast<real_t>(0.1) *
+                                          pusher_params.dt * pusher_params.omegaB0 /
+                                          (SQR(pusher_params
+                                                 .radiative_drag_params.get<real_t>(
+                                                   "synchrotron_gamma_rad")) *
+                                           pusher_params.mass)
+                                      : ZERO }
+      , raddrag_coeff_compton { ((pusher_params.radiative_drag_flags &
+                                  RadiativeDrag::COMPTON) and
+                                 (not HasEmission))
+                                  ? static_cast<real_t>(0.1) *
+                                      pusher_params.dt * pusher_params.omegaB0 /
+                                      (SQR(pusher_params.radiative_drag_params.get<real_t>(
+                                         "compton_gamma_rad")) *
+                                       pusher_params.mass)
+                                  : ZERO }
+      , emission_policy { emission_policy } {
+      raise::ErrorIf(pusher_flags == ParticlePusher::NONE,
+                     "No particle pusher specified",
+                     HERE);
+      raise::ErrorIf(pusher_params.boundaries.size() < 1,
+                     "pusher_params.boundaries defined incorrectly",
+                     HERE);
+      is_absorb_i1min = (pusher_params.boundaries[0].first == PrtlBC::ATMOSPHERE) ||
+                        (pusher_params.boundaries[0].first == PrtlBC::ABSORB);
+      is_absorb_i1max = (pusher_params.boundaries[0].second == PrtlBC::ATMOSPHERE) ||
+                        (pusher_params.boundaries[0].second == PrtlBC::ABSORB);
+      is_periodic_i1min = (pusher_params.boundaries[0].first == PrtlBC::PERIODIC);
+      is_periodic_i1max = (pusher_params.boundaries[0].second == PrtlBC::PERIODIC);
+      is_reflect_i1min = (pusher_params.boundaries[0].first == PrtlBC::REFLECT);
+      is_reflect_i1max = (pusher_params.boundaries[0].second == PrtlBC::REFLECT);
       if constexpr ((D == Dim::_2D) || (D == Dim::_3D)) {
-        raise::ErrorIf(boundaries.size() < 2, "boundaries defined incorrectly", HERE);
-        is_absorb_i2min = (boundaries[1].first == PrtlBC::ATMOSPHERE) ||
-                          (boundaries[1].first == PrtlBC::ABSORB);
-        is_absorb_i2max = (boundaries[1].second == PrtlBC::ATMOSPHERE) ||
-                          (boundaries[1].second == PrtlBC::ABSORB);
-        is_periodic_i2min = (boundaries[1].first == PrtlBC::PERIODIC);
-        is_periodic_i2max = (boundaries[1].second == PrtlBC::PERIODIC);
-        is_reflect_i2min  = (boundaries[1].first == PrtlBC::REFLECT);
-        is_reflect_i2max  = (boundaries[1].second == PrtlBC::REFLECT);
-        is_axis_i2min     = (boundaries[1].first == PrtlBC::AXIS);
-        is_axis_i2max     = (boundaries[1].second == PrtlBC::AXIS);
+        raise::ErrorIf(pusher_params.boundaries.size() < 2,
+                       "pusher_params.boundaries defined incorrectly",
+                       HERE);
+        is_absorb_i2min = (pusher_params.boundaries[1].first == PrtlBC::ATMOSPHERE) ||
+                          (pusher_params.boundaries[1].first == PrtlBC::ABSORB);
+        is_absorb_i2max = (pusher_params.boundaries[1].second ==
+                           PrtlBC::ATMOSPHERE) ||
+                          (pusher_params.boundaries[1].second == PrtlBC::ABSORB);
+        is_periodic_i2min = (pusher_params.boundaries[1].first == PrtlBC::PERIODIC);
+        is_periodic_i2max = (pusher_params.boundaries[1].second == PrtlBC::PERIODIC);
+        is_reflect_i2min = (pusher_params.boundaries[1].first == PrtlBC::REFLECT);
+        is_reflect_i2max = (pusher_params.boundaries[1].second == PrtlBC::REFLECT);
+        is_axis_i2min = (pusher_params.boundaries[1].first == PrtlBC::AXIS);
+        is_axis_i2max = (pusher_params.boundaries[1].second == PrtlBC::AXIS);
       }
       if constexpr (D == Dim::_3D) {
-        raise::ErrorIf(boundaries.size() < 3, "boundaries defined incorrectly", HERE);
-        is_absorb_i3min = (boundaries[2].first == PrtlBC::ATMOSPHERE) ||
-                          (boundaries[2].first == PrtlBC::ABSORB);
-        is_absorb_i3max = (boundaries[2].second == PrtlBC::ATMOSPHERE) ||
-                          (boundaries[2].second == PrtlBC::ABSORB);
-        is_periodic_i3min = (boundaries[2].first == PrtlBC::PERIODIC);
-        is_periodic_i3max = (boundaries[2].second == PrtlBC::PERIODIC);
-        is_reflect_i3min  = (boundaries[2].first == PrtlBC::REFLECT);
-        is_reflect_i3max  = (boundaries[2].second == PrtlBC::REFLECT);
+        raise::ErrorIf(pusher_params.boundaries.size() < 3,
+                       "pusher_params.boundaries defined incorrectly",
+                       HERE);
+        is_absorb_i3min = (pusher_params.boundaries[2].first == PrtlBC::ATMOSPHERE) ||
+                          (pusher_params.boundaries[2].first == PrtlBC::ABSORB);
+        is_absorb_i3max = (pusher_params.boundaries[2].second ==
+                           PrtlBC::ATMOSPHERE) ||
+                          (pusher_params.boundaries[2].second == PrtlBC::ABSORB);
+        is_periodic_i3min = (pusher_params.boundaries[2].first == PrtlBC::PERIODIC);
+        is_periodic_i3max = (pusher_params.boundaries[2].second == PrtlBC::PERIODIC);
+        is_reflect_i3min = (pusher_params.boundaries[2].first == PrtlBC::REFLECT);
+        is_reflect_i3max = (pusher_params.boundaries[2].second == PrtlBC::REFLECT);
       }
     }
 
-    Pusher_kernel(const PrtlPusher::type&     pusher,
-                  bool                        GCA,
-                  bool                        ext_force,
-                  CoolingTags                 cooling,
-                  const ndfield_t<D, 6>&      EB,
-                  spidx_t                     sp,
-                  array_t<int*>&              i1,
-                  array_t<int*>&              i2,
-                  array_t<int*>&              i3,
-                  array_t<int*>&              i1_prev,
-                  array_t<int*>&              i2_prev,
-                  array_t<int*>&              i3_prev,
-                  array_t<prtldx_t*>&         dx1,
-                  array_t<prtldx_t*>&         dx2,
-                  array_t<prtldx_t*>&         dx3,
-                  array_t<prtldx_t*>&         dx1_prev,
-                  array_t<prtldx_t*>&         dx2_prev,
-                  array_t<prtldx_t*>&         dx3_prev,
-                  array_t<real_t*>&           ux1,
-                  array_t<real_t*>&           ux2,
-                  array_t<real_t*>&           ux3,
-                  array_t<real_t*>&           phi,
-                  array_t<short*>&            tag,
-                  const M&                    metric,
-                  simtime_t                   time,
-                  real_t                      coeff,
-                  real_t                      dt,
-                  int                         ni1,
-                  int                         ni2,
-                  int                         ni3,
-                  const boundaries_t<PrtlBC>& boundaries,
-                  real_t                      gca_larmor_max,
-                  real_t                      gca_eovrb_max,
-                  real_t                      coeff_sync,
-                  real_t                      coeff_comp)
-      : Pusher_kernel(pusher,
-                      GCA,
-                      ext_force,
-                      cooling,
-                      EB,
-                      sp,
-                      i1,
-                      i2,
-                      i3,
-                      i1_prev,
-                      i2_prev,
-                      i3_prev,
-                      dx1,
-                      dx2,
-                      dx3,
-                      dx1_prev,
-                      dx2_prev,
-                      dx3_prev,
-                      ux1,
-                      ux2,
-                      ux3,
-                      phi,
-                      tag,
-                      metric,
-                      NoForce_t {},
-                      time,
-                      coeff,
-                      dt,
-                      ni1,
-                      ni2,
-                      ni3,
-                      boundaries,
-                      gca_larmor_max,
-                      gca_eovrb_max,
-                      coeff_sync,
-                      coeff_comp) {}
-
     Inline void synchrotronDrag(index_t                p,
                                 vec_t<Dim::_3D>&       u_prime,
                                 const vec_t<Dim::_3D>& e0,
@@ -454,9 +434,12 @@ namespace kernel::sr {
                                        e_plus_beta_cross_b[1],
                                        e_plus_beta_cross_b[2]) -
                               SQR(beta_dot_e) };
-      ux1(p) += coeff_sync * (kappaR[0] - gamma_prime_sqr * u_prime[0] * chiR_sqr);
-      ux2(p) += coeff_sync * (kappaR[1] - gamma_prime_sqr * u_prime[1] * chiR_sqr);
-      ux3(p) += coeff_sync * (kappaR[2] - gamma_prime_sqr * u_prime[2] * chiR_sqr);
+      ux1(p) += raddrag_coeff_synchrotron *
+                (kappaR[0] - gamma_prime_sqr * u_prime[0] * chiR_sqr);
+      ux2(p) += raddrag_coeff_synchrotron *
+                (kappaR[1] - gamma_prime_sqr * u_prime[1] * chiR_sqr);
+      ux3(p) += raddrag_coeff_synchrotron *
+                (kappaR[2] - gamma_prime_sqr * u_prime[2] * chiR_sqr);
     }
 
     Inline void inverseComptonDrag(index_t p, vec_t<Dim::_3D>& u_prime) const {
@@ -468,9 +451,63 @@ namespace kernel::sr {
       u_prime[2]             *= gamma_prime_sqr;
       gamma_prime_sqr         = SQR(ONE / gamma_prime_sqr);
 
-      ux1(p) -= coeff_comp * gamma_prime_sqr * u_prime[0];
-      ux2(p) -= coeff_comp * gamma_prime_sqr * u_prime[1];
-      ux3(p) -= coeff_comp * gamma_prime_sqr * u_prime[2];
+      ux1(p) -= raddrag_coeff_compton * gamma_prime_sqr * u_prime[0];
+      ux2(p) -= raddrag_coeff_compton * gamma_prime_sqr * u_prime[1];
+      ux3(p) -= raddrag_coeff_compton * gamma_prime_sqr * u_prime[2];
+    }
+
+    Inline void processEmission(index_t                    p,
+                                vec_t<Dim::_3D>&           u_prime,
+                                const coord_t<M::PrtlDim>& xp_Cd,
+                                const coord_t<M::PrtlDim>& xp_Ph,
+                                const vec_t<Dim::_3D>&     ep_Cart,
+                                const vec_t<Dim::_3D>&     bp_Cart) const {
+      typename E::Payload payload;
+      real_t              photon_energy { ZERO };
+      vec_t<Dim::_3D>     delta_u_Ph { ZERO };
+      const auto          emission_response = emission_policy.shouldEmit(xp_Cd,
+                                                                xp_Ph,
+                                                                u_prime,
+                                                                ep_Cart,
+                                                                bp_Cart,
+                                                                delta_u_Ph,
+                                                                payload);
+
+      if (emission_response.second) {
+        ux1(p) += delta_u_Ph[0];
+        ux2(p) += delta_u_Ph[1];
+        ux3(p) += delta_u_Ph[2];
+      }
+
+      if (emission_response.first) {
+        vec_t<Dim::_3D> direction { ZERO };
+        const auto      delta_u_Ph_mag = NORM(delta_u_Ph[0],
+                                         delta_u_Ph[1],
+                                         delta_u_Ph[2]);
+        direction[0]                   = -delta_u_Ph[0] / delta_u_Ph_mag;
+        direction[1]                   = -delta_u_Ph[1] / delta_u_Ph_mag;
+        direction[2]                   = -delta_u_Ph[2] / delta_u_Ph_mag;
+        tuple_t<int, M::Dim>      xi_Cd { 0 };
+        tuple_t<prtldx_t, M::Dim> dxi_Cd { static_cast<prtldx_t>(0) };
+        real_t                    prtl_phi = ZERO;
+        if constexpr (M::Dim == Dim::_1D or M::Dim == Dim::_2D or
+                      M::Dim == Dim::_3D) {
+          xi_Cd[0]  = i1(p);
+          dxi_Cd[0] = dx1(p);
+        }
+        if constexpr (M::Dim == Dim::_2D or M::Dim == Dim::_3D) {
+          xi_Cd[1]  = i2(p);
+          dxi_Cd[1] = dx2(p);
+          if constexpr (M::CoordType != Coord::Cart) {
+            prtl_phi = phi(p);
+          }
+        }
+        if constexpr (M::Dim == Dim::_3D) {
+          xi_Cd[2]  = i3(p);
+          dxi_Cd[2] = dx3(p);
+        }
+        emission_policy.emit(xi_Cd, dxi_Cd, direction, weight(p), prtl_phi, payload);
+      }
     }
 
     Inline void operator()(index_t p) const {
@@ -482,7 +519,7 @@ namespace kernel::sr {
       }
       coord_t<M::PrtlDim> xp_Cd { ZERO };
       getPrtlPos(p, xp_Cd);
-      if (pusher == PrtlPusher::PHOTON) {
+      if (pusher_flags == ParticlePusher::PHOTON) {
         posUpd(false, p, xp_Cd);
         return;
       }
@@ -499,8 +536,8 @@ namespace kernel::sr {
 
       metric.template transform_xyz<Idx::U, Idx::XYZ>(xp_Cd, ei, ei_Cart);
       metric.template transform_xyz<Idx::U, Idx::XYZ>(xp_Cd, bi, bi_Cart);
-      if (cooling != 0) {
-        // backup fields & velocities to use later in cooling
+      if ((radiative_drag_flags != RadiativeDrag::NONE) or HasEmission) {
+        // backup fields & velocities to use later in radiative drag
         ei_Cart_rad[0] = ei_Cart[0];
         ei_Cart_rad[1] = ei_Cart[1];
         ei_Cart_rad[2] = ei_Cart[2];
@@ -511,8 +548,8 @@ namespace kernel::sr {
         u_prime[1]     = ux2(p);
         u_prime[2]     = ux3(p);
       }
-      if constexpr (ExtForce) {
-        coord_t<M::PrtlDim> xp_Ph { ZERO };
+      coord_t<M::PrtlDim> xp_Ph { ZERO };
+      if constexpr (HasExtForce or HasEmission) {
         xp_Ph[0] = metric.template convert<1, Crd::Cd, Crd::Ph>(xp_Cd[0]);
         if constexpr (M::PrtlDim == Dim::_2D or M::PrtlDim == Dim::_3D) {
           xp_Ph[1] = metric.template convert<2, Crd::Cd, Crd::Ph>(xp_Cd[1]);
@@ -520,6 +557,8 @@ namespace kernel::sr {
         if constexpr (M::PrtlDim == Dim::_3D) {
           xp_Ph[2] = metric.template convert<3, Crd::Cd, Crd::Ph>(xp_Cd[2]);
         }
+      }
+      if constexpr (HasExtForce) {
         metric.template transform_xyz<Idx::T, Idx::XYZ>(
           xp_Cd,
           { force.fx1(sp, time, ext_force, xp_Ph),
@@ -527,7 +566,7 @@ namespace kernel::sr {
             force.fx3(sp, time, ext_force, xp_Ph) },
           force_Cart);
       }
-      if (GCA) {
+      if (pusher_flags & ParticlePusher::GCA) {
         /* hybrid GCA/conventional mode --------------------------------- */
         const auto E2 { NORM_SQR(ei_Cart[0], ei_Cart[1], ei_Cart[2]) };
         const auto B2 { NORM_SQR(bi_Cart[0], bi_Cart[1], bi_Cart[2]) };
@@ -536,20 +575,20 @@ namespace kernel::sr {
         if (B2 > ZERO && rL < gca_larmor && (E2 / B2) < gca_EovrB_sqr) {
           is_gca = true;
           // update with GCA
-          if constexpr (ExtForce) {
+          if constexpr (HasExtForce) {
             velUpd(true, p, force_Cart, ei_Cart, bi_Cart);
           } else {
             velUpd(true, p, ei_Cart, bi_Cart);
           }
         } else {
           // update with conventional pusher
-          if constexpr (ExtForce) {
+          if constexpr (HasExtForce) {
             ux1(p) += HALF * dt * force_Cart[0];
             ux2(p) += HALF * dt * force_Cart[1];
             ux3(p) += HALF * dt * force_Cart[2];
           }
           velUpd(false, p, ei_Cart, bi_Cart);
-          if constexpr (ExtForce) {
+          if constexpr (HasExtForce) {
             ux1(p) += HALF * dt * force_Cart[0];
             ux2(p) += HALF * dt * force_Cart[1];
             ux3(p) += HALF * dt * force_Cart[2];
@@ -558,34 +597,36 @@ namespace kernel::sr {
       } else {
         /* conventional pusher mode ------------------------------------- */
         // update with conventional pusher
-        if constexpr (ExtForce) {
+        if constexpr (HasExtForce) {
           ux1(p) += HALF * dt * force_Cart[0];
           ux2(p) += HALF * dt * force_Cart[1];
           ux3(p) += HALF * dt * force_Cart[2];
         }
         velUpd(false, p, ei_Cart, bi_Cart);
-        if constexpr (ExtForce) {
+        if constexpr (HasExtForce) {
           ux1(p) += HALF * dt * force_Cart[0];
           ux2(p) += HALF * dt * force_Cart[1];
           ux3(p) += HALF * dt * force_Cart[2];
         }
       }
-      // cooling
-      if (cooling & Cooling::Synchrotron) {
-        if (!is_gca) {
+      // radiative drag
+      if constexpr (not HasEmission) {
+        if ((not is_gca) and (radiative_drag_flags != RadiativeDrag::NONE)) {
           u_prime[0] = HALF * (u_prime[0] + ux1(p));
           u_prime[1] = HALF * (u_prime[1] + ux2(p));
           u_prime[2] = HALF * (u_prime[2] + ux3(p));
-          synchrotronDrag(p, u_prime, ei_Cart_rad, bi_Cart_rad);
-        }
-      }
-      if (cooling & Cooling::Compton) {
-        if (!is_gca) {
-          u_prime[0] = HALF * (u_prime[0] + ux1(p));
-          u_prime[1] = HALF * (u_prime[1] + ux2(p));
-          u_prime[2] = HALF * (u_prime[2] + ux3(p));
-          inverseComptonDrag(p, u_prime);
+          if (radiative_drag_flags & RadiativeDrag::SYNCHROTRON) {
+            synchrotronDrag(p, u_prime, ei_Cart_rad, bi_Cart_rad);
+          }
+          if (radiative_drag_flags & RadiativeDrag::COMPTON) {
+            inverseComptonDrag(p, u_prime);
+          }
         }
+      } else {
+        u_prime[0] = HALF * (u_prime[0] + ux1(p));
+        u_prime[1] = HALF * (u_prime[1] + ux2(p));
+        u_prime[2] = HALF * (u_prime[2] + ux3(p));
+        processEmission(p, u_prime, xp_Cd, xp_Ph, ei_Cart_rad, bi_Cart_rad);
       }
       // update position
       posUpd(true, p, xp_Cd);
@@ -722,7 +763,7 @@ namespace kernel::sr {
         ux1(p) = upar * b0[0] + vE_Cart[0] * Gamma;
         ux2(p) = upar * b0[1] + vE_Cart[1] * Gamma;
         ux3(p) = upar * b0[2] + vE_Cart[2] * Gamma;
-      } else if (pusher == PrtlPusher::BORIS) {
+      } else if (pusher_flags & ParticlePusher::BORIS) {
         real_t COEFF { coeff };
 
         e0[0] *= COEFF;
@@ -749,7 +790,7 @@ namespace kernel::sr {
         ux1(p) = u0[0];
         ux2(p) = u0[1];
         ux3(p) = u0[2];
-      } else if (pusher == PrtlPusher::VAY) {
+      } else if (pusher_flags & ParticlePusher::VAY) {
         auto COEFF { coeff };
         e0[0] *= COEFF;
         e0[1] *= COEFF;
diff --git a/src/kernels/particle_shapes.hpp b/src/kernels/particle_shapes.hpp
index 6dad879dc..d4b1d9705 100644
--- a/src/kernels/particle_shapes.hpp
+++ b/src/kernels/particle_shapes.hpp
@@ -335,7 +335,7 @@ namespace prtl_shape {
   //              - (161051/460800) * |x|^5 + (14641/276480) * |x|^6 - (1331/241920) * |x|^7 + (121/322560) * |x|^8 - (11/725760) * |x|^9 + (1/3628800) * |x|^10  if 4.5 < |x| ≤ 5.5
   //   0.0                                                                                                                                                        otherwise
   // clang-format on
-  inline real_t S10(const real_t x) {
+  Inline real_t S10(const real_t x) {
     if (x < HALF) {
       return static_cast<real_t>(381773117.0 / 928972800.0) -
              static_cast<real_t>(156409.0 / 737280.0) * SQR(x) +
@@ -434,7 +434,7 @@ namespace prtl_shape {
   //                  + (1/604800) * |x|^10 - (1/39916800) * |x|^11                                     if 5 ≤ |x| < 6
   //   0.0                                                                                              otherwise
   // clang-format on
-  inline real_t S11(const real_t x) {
+  Inline real_t S11(const real_t x) {
     if (x < ONE) {
       return static_cast<real_t>(655177.0 / 1663200.0) -
              static_cast<real_t>(809.0 / 4320.0) * SQR(x) +
diff --git a/src/kernels/prtls_to_phys.hpp b/src/kernels/prtls_to_phys.hpp
index 678fb15ab..6c2234248 100644
--- a/src/kernels/prtls_to_phys.hpp
+++ b/src/kernels/prtls_to_phys.hpp
@@ -22,12 +22,16 @@
 #include "utils/error.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel {
   using namespace ntt;
 
   template <SimEngine::type S, class M, bool T>
+    requires metric::traits::HasD<M> && metric::traits::HasConvert_i<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              S == SimEngine::GRPIC && metric::traits::HasTransform<M>)
   class PrtlToPhys_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr Dimension D = M::Dim;
 
   protected:
diff --git a/src/kernels/reduced_stats.hpp b/src/kernels/reduced_stats.hpp
index bdc7633d6..392d24749 100644
--- a/src/kernels/reduced_stats.hpp
+++ b/src/kernels/reduced_stats.hpp
@@ -17,14 +17,17 @@
 #include "arch/kokkos_aliases.h"
 #include "utils/numeric.h"
 
+#include "metrics/traits.h"
+
 namespace kernel {
   using namespace ntt;
 
   template <SimEngine::type S, class M, StatsID::type F, unsigned short I = 0>
+    requires metric::traits::HasD<M> &&
+             (metric::traits::HasTransform_i<M> || I == 0) &&
+             metric::traits::HasTransform<M> && metric::traits::HasSqrtDetH<M> &&
+             (I <= 3)
   class ReducedFields_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
-    static_assert(I <= 3,
-                  "I must be less than or equal to 3 for ReducedFields_kernel");
     static constexpr auto D = M::Dim;
 
     ndfield_t<D, 6> EM;
@@ -398,15 +401,14 @@ namespace kernel {
   }
 
   template <SimEngine::type S, class M, StatsID::type P>
+    requires metric::traits::HasD<M> &&
+             ((S == SimEngine::SRPIC && metric::traits::HasTransformXYZ<M>) ||
+              S == SimEngine::GRPIC && metric::traits::HasTransform<M>) &&
+             ((P == StatsID::Rho) || (P == StatsID::Charge) ||
+              (P == StatsID::N) || (P == StatsID::Npart) || (P == StatsID::T))
   class ReducedParticleMoments_kernel {
-    static_assert(M::is_metric, "M must be a metric class");
     static constexpr auto D = M::Dim;
 
-    static_assert((P == StatsID::Rho) || (P == StatsID::Charge) ||
-                    (P == StatsID::N) || (P == StatsID::Npart) ||
-                    (P == StatsID::T),
-                  "Invalid stats ID");
-
     const unsigned short     c1, c2;
     const array_t<int*>      i1, i2, i3;
     const array_t<prtldx_t*> dx1, dx2, dx3;
diff --git a/src/kernels/tests/ext_force.cpp b/src/kernels/tests/ext_force.cpp
index 916f7b11e..dbd497837 100644
--- a/src/kernels/tests/ext_force.cpp
+++ b/src/kernels/tests/ext_force.cpp
@@ -153,18 +153,6 @@ void testPusher(const std::vector<std::size_t>& res) {
   put_value<real_t>(ux3, -ux3_0, 1);
   put_value<short>(tag, ParticleTag::alive, 1);
 
-  // Particle boundaries
-  auto boundaries = boundaries_t<PrtlBC> {};
-  boundaries      = {
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
-  };
-
-  const spidx_t sp { 1u };
-
-  const real_t coeff = HALF * dt * omegaB0;
-
   const real_t eps = std::is_same_v<real_t, float> ? 1e-4 : 1e-6;
 
   const auto ext_force = Force { f_mag };
@@ -176,28 +164,54 @@ void testPusher(const std::vector<std::size_t>& res) {
   plog::init(plog::verbose, &file_appender);
   PLOGD << "t,i1,i2,i3,dx1,dx2,dx3,ux1,ux2,ux3";
 
+  kernel::sr::PusherParams pusher_params {};
+  pusher_params.pusher_flags = ParticlePusher::BORIS;
+  pusher_params.mass         = ONE;
+  pusher_params.charge       = ONE;
+  pusher_params.dt           = dt;
+  pusher_params.omegaB0      = omegaB0;
+  pusher_params.ni1          = nx1;
+  pusher_params.ni2          = nx2;
+  pusher_params.ni3          = nx3;
+  pusher_params.boundaries   = {
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
+  };
+  pusher_params.ext_force = true;
+
+  kernel::sr::PusherArrays pusher_arrays {};
+  pusher_arrays.sp       = 1u;
+  pusher_arrays.i1       = i1;
+  pusher_arrays.i2       = i2;
+  pusher_arrays.i3       = i3;
+  pusher_arrays.i1_prev  = i1_prev;
+  pusher_arrays.i2_prev  = i2_prev;
+  pusher_arrays.i3_prev  = i3_prev;
+  pusher_arrays.dx1      = dx1;
+  pusher_arrays.dx2      = dx2;
+  pusher_arrays.dx3      = dx3;
+  pusher_arrays.dx1_prev = dx1_prev;
+  pusher_arrays.dx2_prev = dx2_prev;
+  pusher_arrays.dx3_prev = dx3_prev;
+  pusher_arrays.ux1      = ux1;
+  pusher_arrays.ux2      = ux2;
+  pusher_arrays.ux3      = ux3;
+  pusher_arrays.phi      = phi;
+  pusher_arrays.tag      = tag;
+
   for (auto t { 0u }; t < 100; ++t) {
-    const real_t time = t * dt;
+    const real_t time  = t * dt;
+    pusher_params.time = time;
 
-    // clang-format off
     Kokkos::parallel_for(
       "pusher",
-      CreateRangePolicy<Dim::_1D>({0}, {2}),
-      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>, decltype(force)>(PrtlPusher::BORIS,
-                                                     false, true, kernel::sr::Cooling::None,
-                                                     emfield,
-                                                     sp,
-                                                     i1, i2, i3,
-                                                     i1_prev, i2_prev, i3_prev,
-                                                     dx1, dx2, dx3,
-                                                     dx1_prev, dx2_prev, dx3_prev,
-                                                     ux1, ux2, ux3,
-                                                     phi, tag,
-                                                     metric, force,
-                                                     (simtime_t)time, coeff, dt,
-                                                     nx1, nx2, nx3,
-                                                     boundaries,
-                                                     ZERO, ZERO, ZERO, ZERO));
+      CreateRangePolicy<Dim::_1D>({ 0 }, { 2 }),
+      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>, decltype(force)>(pusher_params,
+                                                                      pusher_arrays,
+                                                                      emfield,
+                                                                      metric,
+                                                                      force));
 
     auto i1_prev_ = Kokkos::create_mirror_view(i1_prev);
     auto i2_prev_ = Kokkos::create_mirror_view(i2_prev);
@@ -236,16 +250,18 @@ void testPusher(const std::vector<std::size_t>& res) {
                  i1_(1),
                  i2_(1),
                  i3_(1),
-                 dx1_( 1),
-                 dx2_( 1),
-                 dx3_( 1),
-                 ux1_( 1),
-                 ux2_( 1),
-                 ux3_( 1));
+                 dx1_(1),
+                 dx2_(1),
+                 dx3_(1),
+                 ux1_(1),
+                 ux2_(1),
+                 ux3_(1));
 
     {
-      const real_t ux1_expect = ux1_0 + (time + dt) * f_mag * std::sin(ONE) * std::sin(ONE);
-      const real_t ux2_expect = ux2_0 + (time + dt) * f_mag * std::sin(ONE) * std::cos(ONE);
+      const real_t ux1_expect = ux1_0 + (time + dt) * f_mag * std::sin(ONE) *
+                                          std::sin(ONE);
+      const real_t ux2_expect = ux2_0 + (time + dt) * f_mag * std::sin(ONE) *
+                                          std::cos(ONE);
       const real_t ux3_expect = ux3_0 + (time + dt) * f_mag * std::cos(ONE);
 
       check_value(t, ux1_(0), ux1_expect, eps, "Particle #1 ux1");
@@ -254,15 +270,16 @@ void testPusher(const std::vector<std::size_t>& res) {
     }
 
     {
-      const real_t ux1_expect = -ux1_0 + (time + dt) * f_mag * std::sin(ONE) * std::sin(ONE);
-      const real_t ux2_expect = -ux2_0 + (time + dt) * f_mag * std::sin(ONE) * std::cos(ONE);
+      const real_t ux1_expect = -ux1_0 + (time + dt) * f_mag * std::sin(ONE) *
+                                           std::sin(ONE);
+      const real_t ux2_expect = -ux2_0 + (time + dt) * f_mag * std::sin(ONE) *
+                                           std::cos(ONE);
       const real_t ux3_expect = -ux3_0 + (time + dt) * f_mag * std::cos(ONE);
 
       check_value(t, ux1_(1), ux1_expect, eps, "Particle #2 ux1");
       check_value(t, ux2_(1), ux2_expect, eps, "Particle #2 ux2");
       check_value(t, ux3_(1), ux3_expect, eps, "Particle #2 ux3");
     }
-
   }
 }
 
diff --git a/src/kernels/tests/gca_pusher.cpp b/src/kernels/tests/gca_pusher.cpp
index 7a2e2d9a3..66c05d7f8 100644
--- a/src/kernels/tests/gca_pusher.cpp
+++ b/src/kernels/tests/gca_pusher.cpp
@@ -140,44 +140,59 @@ void testPusher(const std::vector<std::size_t>& res) {
   put_value<real_t>(ux3, -ux3_0, 1);
   put_value<short>(tag, ParticleTag::alive, 1);
 
-  // Particle boundaries
-  auto boundaries = boundaries_t<PrtlBC> {};
-  boundaries      = {
+  const real_t eps = std::is_same_v<real_t, float> ? 1e-3 : 1e-6;
+
+  kernel::sr::PusherParams pusher_params {};
+  pusher_params.pusher_flags = ParticlePusher::BORIS | ParticlePusher::GCA;
+  pusher_params.mass         = ONE;
+  pusher_params.charge       = ONE;
+  pusher_params.dt           = dt;
+  pusher_params.omegaB0      = omegaB0;
+  pusher_params.ni1          = nx1;
+  pusher_params.ni2          = nx2;
+  pusher_params.ni3          = nx3;
+  pusher_params.boundaries   = {
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
   };
-
-  const spidx_t sp { 1u };
-
-  const real_t coeff = HALF * dt * omegaB0;
-
-  const real_t eps = std::is_same_v<real_t, float> ? 1e-3 : 1e-6;
+  pusher_params.gca_params.set("larmor_max", (real_t)10000.0);
+  pusher_params.gca_params.set("e_ovr_b_max", ONE);
+
+  kernel::sr::PusherArrays pusher_arrays {};
+  pusher_arrays.sp       = 1u;
+  pusher_arrays.i1       = i1;
+  pusher_arrays.i2       = i2;
+  pusher_arrays.i3       = i3;
+  pusher_arrays.i1_prev  = i1_prev;
+  pusher_arrays.i2_prev  = i2_prev;
+  pusher_arrays.i3_prev  = i3_prev;
+  pusher_arrays.dx1      = dx1;
+  pusher_arrays.dx2      = dx2;
+  pusher_arrays.dx3      = dx3;
+  pusher_arrays.dx1_prev = dx1_prev;
+  pusher_arrays.dx2_prev = dx2_prev;
+  pusher_arrays.dx3_prev = dx3_prev;
+  pusher_arrays.ux1      = ux1;
+  pusher_arrays.ux2      = ux2;
+  pusher_arrays.ux3      = ux3;
+  pusher_arrays.phi      = phi;
+  pusher_arrays.tag      = tag;
 
   for (auto t { 0u }; t < 2000; ++t) {
-    // clang-format off
+    pusher_params.time = t * dt;
+
     Kokkos::parallel_for(
       "pusher",
-      CreateRangePolicy<Dim::_1D>({0}, {2}),
-      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(PrtlPusher::BORIS,
-                                                     true, false, kernel::sr::Cooling::None,
+      CreateRangePolicy<Dim::_1D>({ 0 }, { 2 }),
+      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(pusher_params,
+                                                     pusher_arrays,
                                                      emfield,
-                                                     sp,
-                                                     i1, i2, i3,
-                                                     i1_prev, i2_prev, i3_prev,
-                                                     dx1, dx2, dx3,
-                                                     dx1_prev, dx2_prev, dx3_prev,
-                                                     ux1, ux2, ux3,
-                                                     phi, tag,
-                                                     metric,
-                                                     ZERO, coeff, dt,
-                                                     nx1, nx2, nx3,
-                                                     boundaries,
-                                                     (real_t)10000.0, ONE, ZERO, ZERO));
-
-    auto ux1_      = Kokkos::create_mirror_view(ux1);
-    auto ux2_      = Kokkos::create_mirror_view(ux2);
-    auto ux3_      = Kokkos::create_mirror_view(ux3);
+                                                     metric));
+
+    auto ux1_ = Kokkos::create_mirror_view(ux1);
+    auto ux2_ = Kokkos::create_mirror_view(ux2);
+    auto ux3_ = Kokkos::create_mirror_view(ux3);
     Kokkos::deep_copy(ux1_, ux1);
     Kokkos::deep_copy(ux2_, ux2);
     Kokkos::deep_copy(ux3_, ux3);
diff --git a/src/kernels/tests/prtl_bc.cpp b/src/kernels/tests/prtl_bc.cpp
index f75c90bc4..0da127498 100644
--- a/src/kernels/tests/prtl_bc.cpp
+++ b/src/kernels/tests/prtl_bc.cpp
@@ -50,7 +50,6 @@ void testPeriodicBC(const std::vector<std::size_t>&      res,
   errorIf(res.size() != M::Dim, "res.size() != M::Dim");
   errorIf(M::CoordType != Coord::Cart, "M::CoordType != Coord::Cart");
   // aliases
-  const auto NoGCA      = false;
   const auto NoExtForce = false;
 
   real_t sx = ZERO, sy = ZERO, sz = ZERO;
@@ -230,37 +229,49 @@ void testPeriodicBC(const std::vector<std::size_t>&      res,
     put_value<short>(tag, ParticleTag::alive, prtl_idx);
   }
 
-  // Particle boundaries
-  auto boundaries = boundaries_t<PrtlBC> {};
-  boundaries      = {
+  real_t     time   = ZERO;
+  const auto n_iter = 100;
+
+  kernel::sr::PusherParams pusher_params {};
+  pusher_params.pusher_flags = ParticlePusher::BORIS;
+  pusher_params.mass         = ONE;
+  pusher_params.charge       = ONE;
+  pusher_params.dt           = dt;
+  pusher_params.omegaB0      = ONE;
+  pusher_params.ni1          = nx1;
+  pusher_params.ni2          = nx2;
+  pusher_params.ni3          = nx3;
+  pusher_params.boundaries   = {
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
     { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
   };
 
-  real_t     time   = ZERO;
-  const auto n_iter = 100;
+  kernel::sr::PusherArrays pusher_arrays {};
+  pusher_arrays.sp       = 1u;
+  pusher_arrays.i1       = i1;
+  pusher_arrays.i2       = i2;
+  pusher_arrays.i3       = i3;
+  pusher_arrays.i1_prev  = i1_prev;
+  pusher_arrays.i2_prev  = i2_prev;
+  pusher_arrays.i3_prev  = i3_prev;
+  pusher_arrays.dx1      = dx1;
+  pusher_arrays.dx2      = dx2;
+  pusher_arrays.dx3      = dx3;
+  pusher_arrays.dx1_prev = dx1_prev;
+  pusher_arrays.dx2_prev = dx2_prev;
+  pusher_arrays.dx3_prev = dx3_prev;
+  pusher_arrays.ux1      = ux1;
+  pusher_arrays.ux2      = ux2;
+  pusher_arrays.ux3      = ux3;
+  pusher_arrays.phi      = phi;
+  pusher_arrays.tag      = tag;
 
   for (auto n { 0 }; n < n_iter; ++n) {
-    // clang-format off
     Kokkos::parallel_for(
-      "pusher", CreateRangePolicy<Dim::_1D>({ 0 }, { 2 }),
-      kernel::sr::Pusher_kernel<M>(PrtlPusher::BORIS,
-                                   NoGCA, NoExtForce, kernel::sr::Cooling::None,
-                                   emfield,
-                                   sp_idx,
-                                   i1, i2, i3,
-                                   i1_prev, i2_prev, i3_prev,
-                                   dx1, dx2, dx3,
-                                   dx1_prev, dx2_prev, dx3_prev,
-                                   ux1, ux2, ux3,
-                                   phi, tag,
-                                   metric,
-                                   time, coeff, dt,
-                                   nx1, nx2, nx3,
-                                   boundaries,
-                                   ZERO, ZERO, ZERO, ZERO));
-    // clang-format on
+      "pusher",
+      CreateRangePolicy<Dim::_1D>({ 0 }, { 2 }),
+      kernel::sr::Pusher_kernel<M>(pusher_params, pusher_arrays, emfield, metric));
     auto i1_  = Kokkos::create_mirror_view(i1);
     auto i2_  = Kokkos::create_mirror_view(i2);
     auto i3_  = Kokkos::create_mirror_view(i3);
diff --git a/src/kernels/tests/pusher.cpp b/src/kernels/tests/pusher.cpp
index ddbc1be8a..4e90ce7a7 100644
--- a/src/kernels/tests/pusher.cpp
+++ b/src/kernels/tests/pusher.cpp
@@ -136,17 +136,6 @@ void testPusher(const std::vector<std::size_t>& res) {
   put_value<short>(tag, ParticleTag::alive, 1);
 
   // Particle boundaries
-  auto boundaries = boundaries_t<PrtlBC> {};
-  boundaries      = {
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
-    { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
-  };
-
-  const spidx_t sp { 1u };
-
-  const real_t coeff = HALF * dt * omegaB0;
-
   const auto u0_dot_b      = (ux1_0 * bx1 + ux2_0 * bx2 + ux3_0 * bx3) / b_mag;
   const auto u0_cross_b_x1 = (ux2_0 * bx3 - ux3_0 * bx2) / b_mag;
   const auto u0_cross_b_x2 = (ux3_0 * bx1 - ux1_0 * bx3) / b_mag;
@@ -154,47 +143,62 @@ void testPusher(const std::vector<std::size_t>& res) {
 
   const real_t eps = std::is_same_v<real_t, float> ? 1e-2 : 1e-3;
 
+  kernel::sr::PusherParams pusher_params {};
+  pusher_params.mass       = ONE;
+  pusher_params.charge     = ONE;
+  pusher_params.dt         = dt;
+  pusher_params.omegaB0    = omegaB0;
+  pusher_params.ni1        = nx1;
+  pusher_params.ni2        = nx2;
+  pusher_params.ni3        = nx3;
+  pusher_params.boundaries = {
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC },
+    { PrtlBC::PERIODIC, PrtlBC::PERIODIC }
+  };
+
+  kernel::sr::PusherArrays pusher_arrays {};
+  pusher_arrays.sp       = 1u;
+  pusher_arrays.i1       = i1;
+  pusher_arrays.i2       = i2;
+  pusher_arrays.i3       = i3;
+  pusher_arrays.i1_prev  = i1_prev;
+  pusher_arrays.i2_prev  = i2_prev;
+  pusher_arrays.i3_prev  = i3_prev;
+  pusher_arrays.dx1      = dx1;
+  pusher_arrays.dx2      = dx2;
+  pusher_arrays.dx3      = dx3;
+  pusher_arrays.dx1_prev = dx1_prev;
+  pusher_arrays.dx2_prev = dx2_prev;
+  pusher_arrays.dx3_prev = dx3_prev;
+  pusher_arrays.ux1      = ux1;
+  pusher_arrays.ux2      = ux2;
+  pusher_arrays.ux3      = ux3;
+  pusher_arrays.phi      = phi;
+  pusher_arrays.tag      = tag;
+
   for (auto t { 0u }; t < 2000; ++t) {
-    const real_t time = t * dt;
+    const real_t time  = t * dt;
+    pusher_params.time = time;
 
-    // clang-format off
+    pusher_params.pusher_flags = ParticlePusher::BORIS;
     Kokkos::parallel_for(
       "pusher",
-      CreateRangePolicy<Dim::_1D>({0}, {1}),
-      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(PrtlPusher::BORIS,
-                                                     false, false, kernel::sr::Cooling::None,
+      CreateRangePolicy<Dim::_1D>({ 0 }, { 1 }),
+      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(pusher_params,
+                                                     pusher_arrays,
                                                      emfield,
-                                                     sp,
-                                                     i1, i2, i3,
-                                                     i1_prev, i2_prev, i3_prev,
-                                                     dx1, dx2, dx3,
-                                                     dx1_prev, dx2_prev, dx3_prev,
-                                                     ux1, ux2, ux3,
-                                                     phi, tag,
-                                                     metric,
-                                                     ZERO, coeff, dt,
-                                                     nx1, nx2, nx3,
-                                                     boundaries,
-                                                     ZERO, ZERO, ZERO, ZERO));
+                                                     metric));
+
+    pusher_params.pusher_flags = ParticlePusher::VAY;
 
     Kokkos::parallel_for(
       "pusher",
-      CreateRangePolicy<Dim::_1D>({1}, {2}),
-      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(PrtlPusher::VAY,
-                                                     false, false, kernel::sr::Cooling::None,
+      CreateRangePolicy<Dim::_1D>({ 1 }, { 2 }),
+      kernel::sr::Pusher_kernel<Minkowski<Dim::_3D>>(pusher_params,
+                                                     pusher_arrays,
                                                      emfield,
-                                                     sp,
-                                                     i1, i2, i3,
-                                                     i1_prev, i2_prev, i3_prev,
-                                                     dx1, dx2, dx3,
-                                                     dx1_prev, dx2_prev, dx3_prev,
-                                                     ux1, ux2, ux3,
-                                                     phi, tag,
-                                                     metric,
-                                                     ZERO, coeff, dt,
-                                                     nx1, nx2, nx3,
-                                                     boundaries,
-                                                     ZERO, ZERO, ZERO, ZERO));
+                                                     metric));
 
     auto i1_prev_ = Kokkos::create_mirror_view(i1_prev);
     auto i2_prev_ = Kokkos::create_mirror_view(i2_prev);
@@ -252,7 +256,6 @@ void testPusher(const std::vector<std::size_t>& res) {
     check_value(t, ux1_(1), ux1_expect, eps, "Particle #2 ux1");
     check_value(t, ux2_(1), ux2_expect, eps, "Particle #2 ux2");
     check_value(t, ux3_(1), ux3_expect, eps, "Particle #2 ux3");
-
   }
 }
 
diff --git a/src/metrics/kerr_schild.h b/src/metrics/kerr_schild.h
index 14441f995..4df88cf4c 100644
--- a/src/metrics/kerr_schild.h
+++ b/src/metrics/kerr_schild.h
@@ -40,6 +40,7 @@ namespace metric {
 
     const real_t dr, dtheta, dphi;
     const real_t dr_inv, dtheta_inv, dphi_inv;
+    const bool   small_angle;
 
     Inline auto Delta(real_t r) const -> real_t {
       return SQR(r) - TWO * r + SQR(a);
@@ -85,7 +86,8 @@ namespace metric {
       , dphi { (x3_max - x3_min) / nx3 }
       , dr_inv { ONE / dr }
       , dtheta_inv { ONE / dtheta }
-      , dphi_inv { ONE / dphi } {
+      , dphi_inv { ONE / dphi }
+      , small_angle { HALF * dtheta < constant::SMALL_ANGLE } {
       set_dxMin(find_dxMin());
     }
 
@@ -443,12 +445,21 @@ namespace metric {
     /**
      * differential area at the pole (used in axisymmetric solvers)
      * @param x1 radial coordinate along the axis (code units)
+     * @note uses small-angle approximation when the resolution is too high
      */
     Inline auto polar_area(real_t x1) const -> real_t {
-      return dr * (SQR(x1 * dr + x1_min) + SQR(a)) *
-             math::sqrt(ONE + TWO * (x1 * dr + x1_min) /
-                                (SQR(x1 * dr + x1_min) + SQR(a))) *
-             (ONE - math::cos(HALF * dtheta));
+      if (small_angle) {
+        return dr * (SQR(x1 * dr + x1_min) + SQR(a)) *
+              math::sqrt(ONE + TWO * (x1 * dr + x1_min) /
+                                  (SQR(x1 * dr + x1_min) + SQR(a))) *
+               (static_cast<real_t>(48) - SQR(dtheta)) * SQR(dtheta) /
+               static_cast<real_t>(384);
+      } else {
+        return dr * (SQR(x1 * dr + x1_min) + SQR(a)) *
+              math::sqrt(ONE + TWO * (x1 * dr + x1_min) /
+                                  (SQR(x1 * dr + x1_min) + SQR(a))) *
+              (ONE - math::cos(HALF * dtheta));
+      }
     }
 
     /**
diff --git a/src/metrics/metric_base.h b/src/metrics/metric_base.h
index 8b0e5cae0..6284cd9ec 100644
--- a/src/metrics/metric_base.h
+++ b/src/metrics/metric_base.h
@@ -84,7 +84,6 @@ namespace metric {
    */
   template <Dimension D>
   struct MetricBase {
-    static constexpr bool      is_metric { true };
     static constexpr Dimension Dim { D };
 
     MetricBase(const std::vector<ncells_t>& res, const boundaries_t<real_t>& ext)
diff --git a/src/metrics/qkerr_schild.h b/src/metrics/qkerr_schild.h
index 9b608f35f..90f366efb 100644
--- a/src/metrics/qkerr_schild.h
+++ b/src/metrics/qkerr_schild.h
@@ -39,6 +39,7 @@ namespace metric {
     const real_t chi_min, eta_min, phi_min;
     const real_t dchi, deta, dphi;
     const real_t dchi_inv, deta_inv, dphi_inv;
+    const bool   small_angle;
 
     Inline auto Delta(real_t r) const -> real_t {
       return SQR(r) - TWO * r + SQR(a);
@@ -89,7 +90,8 @@ namespace metric {
       , dphi { (x3_max - phi_min) / nx3 }
       , dchi_inv { ONE / dchi }
       , deta_inv { ONE / deta }
-      , dphi_inv { ONE / dphi } {
+      , dphi_inv { ONE / dphi } 
+      , small_angle { eta2theta(HALF * deta) < constant::SMALL_ANGLE } {
       set_dxMin(find_dxMin());
     }
 
@@ -503,15 +505,27 @@ namespace metric {
      * differential area at the pole (used in axisymmetric solvers)
      * @note approximate solution for the polar area
      * @param x1 radial coordinate along the axis (code units)
+     * @note uses small-angle approximation when the resolution is too high
      */
     Inline auto polar_area(real_t x1) const -> real_t {
       if constexpr (D != Dim::_1D) {
-        return dchi * math::exp(x1 * dchi + chi_min) *
-               (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a)) *
-               math::sqrt(
-                 ONE + TWO * (r0 + math::exp(x1 * dchi + chi_min)) /
-                         (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a))) *
-               (ONE - math::cos(eta2theta(HALF * deta)));
+        if (small_angle) { 
+          const real_t dtheta = eta2theta(HALF * deta);
+          return dchi * math::exp(x1 * dchi + chi_min) *
+                (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a)) *
+                math::sqrt(
+                  ONE + TWO * (r0 + math::exp(x1 * dchi + chi_min)) /
+                          (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a))) *
+                (static_cast<real_t>(48) - SQR(dtheta)) * SQR(dtheta) /
+                 static_cast<real_t>(384);
+        } else {
+          return dchi * math::exp(x1 * dchi + chi_min) *
+                (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a)) *
+                math::sqrt(
+                  ONE + TWO * (r0 + math::exp(x1 * dchi + chi_min)) /
+                          (SQR(r0 + math::exp(x1 * dchi + chi_min)) + SQR(a))) *
+                (ONE - math::cos(eta2theta(HALF * deta)));
+        }
       }
     }
 
diff --git a/src/metrics/traits.h b/src/metrics/traits.h
new file mode 100644
index 000000000..d499e6768
--- /dev/null
+++ b/src/metrics/traits.h
@@ -0,0 +1,167 @@
+/**
+ * @file metrics/traits.h
+ * @brief Defines a set of traits to check if a metric class satisfies certain conditions
+ * @implements
+ *   - metric::traits::HasD<> - checks if metric has Dim static member
+ *   - metric::traits::HasCoordType<> - checks if metric has CoordType static member
+ *   - metric::traits::HasH_ij<> - checks if metric has h_ij method
+ *   - metric::traits::HasHij<> - checks if metric has hij method
+ *   - metric::traits::HasSqrtH_ij<> - checks if metric has sqrt_h_ij method
+ *   - metric::traits::HasSqrtDetH<> - checks if metric has sqrt_det_h method
+ *   - metric::traits::HasSqrtDetHTilde<> - checks if metric has sqrt_det_h_tilde method
+ *   - metric::traits::HasPolarArea<> - checks if metric has polar_area method
+ *   - metric::traits::HasTotVolume<> - checks if metric has totVolume method
+ *   - metric::traits::HasTransform_i<> - checks if metric has transform method for single component
+ *   - metric::traits::HasTransform<> - checks if metric has transform method for vector
+ *   - metric::traits::HasTransformXYZ<> - checks if metric has transform_xyz method for vector
+ *   - metric::traits::HasConvert_i<> - checks if metric has convert method for single component
+ *   - metric::traits::HasConvert<> - checks if metric has convert method for vector
+ *   - metric::traits::HasConvertXYZ<> - checks if metric has convert_xyz method for vector
+ *   - metric::traits::HasAlpha<> - checks if metric has alpha method
+ *   - metric::traits::HasBeta1<> - checks if metric has beta1 method
+ *   - metric::traits::HasMetricDerivatives<> - checks if metric has metric derivatives methods
+ * @namespaces:
+ *   - metric::traits::
+ */
+#ifndef METRICS_TRAITS_H
+#define METRICS_TRAITS_H
+
+#include "enums.h"
+#include "global.h"
+
+namespace metric {
+  namespace traits {
+
+    template <class M>
+    concept HasD = requires {
+      { M::Dim } -> std::convertible_to<Dimension>;
+    };
+
+    template <class M>
+    concept HasPrtlDim = requires {
+      { M::PrtlDim } -> std::convertible_to<Dimension>;
+    };
+
+    template <class M>
+    concept HasCoordType = requires {
+      { M::CoordType } -> std::convertible_to<ntt::Coord::type>;
+    };
+
+    template <class M>
+    concept HasH_ij = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.template h_<1, 1>(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasHij = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.template h<1, 1>(xi) } -> std::convertible_to<real_t>;
+    };
+    template <class M>
+    concept HasSqrtH_ij = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.template sqrt_h_<1, 1>(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasSqrtDetH = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.sqrt_det_h(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasSqrtDetHTilde = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.sqrt_det_h_tilde(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasPolarArea = requires(const M& m, real_t xi_2) {
+      { m.polar_area(xi_2) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasTotVolume = requires(const M& m) {
+      { m.totVolume() } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasTransform_i = requires(const M&               m,
+                                      const coord_t<M::Dim>& xi,
+                                      real_t                 v_in) {
+      {
+        m.template transform<1, Idx::U, Idx::D>(xi, v_in)
+      } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasTransform = requires(const M&               m,
+                                    const coord_t<M::Dim>& xi,
+                                    const vec_t<Dim::_3D>& v_in,
+                                    vec_t<Dim::_3D>&       v_out) {
+      {
+        m.template transform<Idx::U, Idx::D>(xi, v_in, v_out)
+      } -> std::same_as<void>;
+    };
+
+    template <class M>
+    concept HasTransformXYZ = requires(const M&                   m,
+                                       const coord_t<M::PrtlDim>& xi,
+                                       const vec_t<Dim::_3D>&     v_in,
+                                       vec_t<Dim::_3D>&           v_out) {
+      {
+        m.template transform_xyz<Idx::XYZ, Idx::D>(xi, v_in, v_out)
+      } -> std::same_as<void>;
+    };
+
+    template <class M>
+    concept HasConvert_i = requires(const M& m, real_t x) {
+      {
+        m.template convert<1, Crd::Cd, Crd::Ph>(x)
+      } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasConvert = requires(const M&               m,
+                                  const coord_t<M::Dim>& x_in,
+                                  coord_t<M::Dim>&       x_out) {
+      {
+        m.template convert<Crd::Cd, Crd::Ph>(x_in, x_out)
+      } -> std::same_as<void>;
+    };
+
+    template <class M>
+    concept HasConvertXYZ = requires(const M&                   m,
+                                     const coord_t<M::PrtlDim>& x_in,
+                                     coord_t<M::PrtlDim>&       x_out) {
+      {
+        m.template convert_xyz<Crd::Cd, Crd::XYZ>(x_in, x_out)
+      } -> std::same_as<void>;
+    };
+
+    template <class M>
+    concept HasAlpha = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.alpha(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasBeta1 = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.beta1(xi) } -> std::convertible_to<real_t>;
+    };
+
+    template <class M>
+    concept HasMetricDerivatives = requires(const M& m, const coord_t<M::Dim>& xi) {
+      { m.dr_alpha(xi) } -> std::convertible_to<real_t>;
+      { m.dr_beta1(xi) } -> std::convertible_to<real_t>;
+      { m.dr_h11(xi) } -> std::convertible_to<real_t>;
+      { m.dr_h22(xi) } -> std::convertible_to<real_t>;
+      { m.dr_h33(xi) } -> std::convertible_to<real_t>;
+      { m.dr_h13(xi) } -> std::convertible_to<real_t>;
+      { m.dt_alpha(xi) } -> std::convertible_to<real_t>;
+      { m.dt_beta1(xi) } -> std::convertible_to<real_t>;
+      { m.dt_h11(xi) } -> std::convertible_to<real_t>;
+      { m.dt_h22(xi) } -> std::convertible_to<real_t>;
+      { m.dt_h33(xi) } -> std::convertible_to<real_t>;
+      { m.dt_h13(xi) } -> std::convertible_to<real_t>;
+    };
+
+  } // namespace traits
+} // namespace metric
+
+#endif // METRICS_TRAITS_H
diff --git a/src/output/CMakeLists.txt b/src/output/CMakeLists.txt
index e15378c62..8c7e9815b 100644
--- a/src/output/CMakeLists.txt
+++ b/src/output/CMakeLists.txt
@@ -39,7 +39,9 @@ add_library(ntt_output ${SOURCES})
 set(libs ntt_global)
 add_dependencies(ntt_output ${libs})
 target_link_libraries(ntt_output PUBLIC ${libs})
-target_link_libraries(ntt_output PRIVATE stdc++fs)
+if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+  target_link_libraries(ntt_output PRIVATE stdc++fs)
+endif()
 
 target_include_directories(
   ntt_output
diff --git a/src/output/tests/CMakeLists.txt b/src/output/tests/CMakeLists.txt
index f6f460ae9..6809e37b0 100644
--- a/src/output/tests/CMakeLists.txt
+++ b/src/output/tests/CMakeLists.txt
@@ -18,7 +18,10 @@ function(gen_test title is_parallel)
 
   set(libs ntt_output ntt_global ntt_metrics ntt_framework)
   add_dependencies(${exec} ${libs})
-  target_link_libraries(${exec} PRIVATE ${libs} stdc++fs)
+  if (NOT "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
+    list(APPEND libs stdc++fs)
+  endif()
+  target_link_libraries(${exec} PRIVATE ${libs})
 
   if(${is_parallel})
     add_test(NAME "OUTPUT::${title}"
diff --git a/src/output/tests/writer-mpi.cpp b/src/output/tests/writer-mpi.cpp
index dad981a40..382f880c6 100644
--- a/src/output/tests/writer-mpi.cpp
+++ b/src/output/tests/writer-mpi.cpp
@@ -7,7 +7,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 #include <mpi.h>
 
 #include <filesystem>
diff --git a/src/output/tests/writer-nompi.cpp b/src/output/tests/writer-nompi.cpp
index a185b1777..331b0ec90 100644
--- a/src/output/tests/writer-nompi.cpp
+++ b/src/output/tests/writer-nompi.cpp
@@ -7,7 +7,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 
 #include <filesystem>
 #include <iostream>
@@ -71,7 +71,7 @@ auto main(int argc, char* argv[]) -> int {
     {
       // write
       auto writer = out::Writer();
-      writer.init(&adios, "bpfile", "test", false);
+      writer.init(&adios, "bpfile", "test");
       writer.defineMeshLayout({ nx1, nx2, nx3 },
                               { 0, 0, 0 },
                               { nx1, nx2, nx3 },
@@ -101,108 +101,119 @@ auto main(int argc, char* argv[]) -> int {
       // read
       adios2::IO io = adios.DeclareIO("read-test");
       io.SetEngine("BPFile");
-      adios2::Engine reader = io.Open("test.bp", adios2::Mode::Read);
-
-      for (auto step = 0u; reader.BeginStep() == adios2::StepStatus::OK; ++step) {
-        const auto layoutRight = io.InquireAttribute<int>("LayoutRight").Data()[0] ==
-                                 1;
-
-        raise::ErrorIf(io.InquireAttribute<std::size_t>("NGhosts").Data()[0] != 0,
-                       "NGhosts is not correct",
-                       HERE);
-        raise::ErrorIf(io.InquireAttribute<std::size_t>("Dimension").Data()[0] != 3,
-                       "Dimension is not correct",
-                       HERE);
-
-        timestep_t step_read;
-        simtime_t  time_read;
-
-        reader.Get(io.InquireVariable<timestep_t>("Step"),
-                   &step_read,
-                   adios2::Mode::Sync);
-        reader.Get(io.InquireVariable<simtime_t>("Time"),
-                   &time_read,
-                   adios2::Mode::Sync);
-        raise::ErrorIf(step_read != (step + 1) * 10, "Step is not correct", HERE);
-        raise::ErrorIf((float)time_read != 123 + (float)step * 0.4f,
-                       "Time is not correct",
-                       HERE);
-
-        array_t<real_t***> field_read {};
-
-        int cntr = 0;
-        for (const auto& name : field_names) {
-          auto fieldVar = io.InquireVariable<real_t>(name);
-          if (fieldVar) {
-            raise::ErrorIf(fieldVar.Shape().size() != 3,
-                           fmt::format("%s is not 3D", name.c_str()),
-                           HERE);
-
-            auto     dims  = fieldVar.Shape();
-            ncells_t nx1_r = dims[0];
-            ncells_t nx2_r = dims[1];
-            ncells_t nx3_r = dims[2];
-            if (!layoutRight) {
-              std::swap(nx1_r, nx3_r);
-            }
-            raise::ErrorIf((nx1_r != CEILDIV(nx1, dwn1)) ||
-                             (nx2_r != CEILDIV(nx2, dwn2)) ||
-                             (nx3_r != CEILDIV(nx3, dwn3)),
-                           fmt::format("%s = %ldx%ldx%ld is not %dx%dx%d",
-                                       name.c_str(),
-                                       nx1_r,
-                                       nx2_r,
-                                       nx3_r,
-                                       CEILDIV(nx1, dwn1),
-                                       CEILDIV(nx2, dwn2),
-                                       CEILDIV(nx3, dwn3)),
-                           HERE);
-
-            if (!layoutRight) {
-              std::swap(nx1_r, nx3_r);
-            }
-            fieldVar.SetSelection(
-              adios2::Box<adios2::Dims>({ 0, 0, 0 }, { nx1_r, nx2_r, nx3_r }));
-            if (!layoutRight) {
-              std::swap(nx1_r, nx3_r);
+
+      for (const auto time : { 10u, 20u }) {
+        namespace fs          = std::filesystem;
+        adios2::Engine reader = io.Open(
+          fs::path("test") / fs::path("fields") /
+            fs::path(fmt::format("fields.%08d.bp", time)),
+          adios2::Mode::Read);
+        for (auto st = 0u; reader.BeginStep() == adios2::StepStatus::OK; ++st) {
+          const auto layoutRight = io.InquireAttribute<int>("LayoutRight").Data()[0] ==
+                                   1;
+
+          raise::ErrorIf(io.InquireAttribute<std::size_t>("NGhosts").Data()[0] != 0,
+                         "NGhosts is not correct",
+                         HERE);
+          raise::ErrorIf(
+            io.InquireAttribute<std::size_t>("Dimension").Data()[0] != 3,
+            "Dimension is not correct",
+            HERE);
+
+          timestep_t step_read;
+          simtime_t  time_read;
+
+          reader.Get(io.InquireVariable<timestep_t>("Step"),
+                     &step_read,
+                     adios2::Mode::Sync);
+          reader.Get(io.InquireVariable<simtime_t>("Time"),
+                     &time_read,
+                     adios2::Mode::Sync);
+          raise::ErrorIf(step_read != time, "Step is not correct", HERE);
+          raise::ErrorIf((float)time_read !=
+                           123 + ((float)(time) / 10.0f - 1.0f) * 0.4f,
+                         "Time is not correct",
+                         HERE);
+
+          array_t<real_t***> field_read {};
+
+          int cntr = 0;
+          for (const auto& name : field_names) {
+            auto fieldVar = io.InquireVariable<real_t>(name);
+            if (fieldVar) {
+              raise::ErrorIf(fieldVar.Shape().size() != 3,
+                             fmt::format("%s is not 3D", name.c_str()),
+                             HERE);
+
+              auto     dims  = fieldVar.Shape();
+              ncells_t nx1_r = dims[0];
+              ncells_t nx2_r = dims[1];
+              ncells_t nx3_r = dims[2];
+              if (!layoutRight) {
+                std::swap(nx1_r, nx3_r);
+              }
+              raise::ErrorIf((nx1_r != CEILDIV(nx1, dwn1)) ||
+                               (nx2_r != CEILDIV(nx2, dwn2)) ||
+                               (nx3_r != CEILDIV(nx3, dwn3)),
+                             fmt::format("%s = %ldx%ldx%ld is not %dx%dx%d",
+                                         name.c_str(),
+                                         nx1_r,
+                                         nx2_r,
+                                         nx3_r,
+                                         CEILDIV(nx1, dwn1),
+                                         CEILDIV(nx2, dwn2),
+                                         CEILDIV(nx3, dwn3)),
+                             HERE);
+
+              if (!layoutRight) {
+                std::swap(nx1_r, nx3_r);
+              }
+              fieldVar.SetSelection(
+                adios2::Box<adios2::Dims>({ 0, 0, 0 }, { nx1_r, nx2_r, nx3_r }));
+              if (!layoutRight) {
+                std::swap(nx1_r, nx3_r);
+              }
+              field_read        = array_t<real_t***>(name, nx1_r, nx2_r, nx3_r);
+              auto field_read_h = Kokkos::create_mirror_view(field_read);
+              reader.Get(fieldVar, field_read_h.data(), adios2::Mode::Sync);
+              Kokkos::deep_copy(field_read, field_read_h);
+
+              Kokkos::parallel_for(
+                "check",
+                CreateRangePolicy<Dim::_3D>({ 0, 0, 0 }, { nx1_r, nx2_r, nx3_r }),
+                Lambda(index_t i1, index_t i2, index_t i3) {
+                  if (not cmp::AlmostEqual(field_read(i1, i2, i3),
+                                           field(i1 * dwn1 + i1min,
+                                                 i2 * dwn2 + i2min,
+                                                 i3 * dwn3 + i3min,
+                                                 cntr))) {
+                    Kokkos::printf(
+                      "\n:::::::::::::::\nfield_read(%ld, %ld, %ld) = %f != "
+                      "field(%ld, %ld, %ld, %d) = %f\n:::::::::::::::\n",
+                      i1,
+                      i2,
+                      i3,
+                      field_read(i1, i2, i3),
+                      i1 * dwn1 + i1min,
+                      i2 * dwn2 + i2min,
+                      i3 * dwn3 + i3min,
+                      cntr,
+                      field(i1 * dwn1 + i1min,
+                            i2 * dwn2 + i2min,
+                            i3 * dwn3 + i3min,
+                            cntr));
+                    raise::KernelError(HERE, "Field is not read correctly");
+                  }
+                });
+            } else {
+              raise::Error("Field not found", HERE);
             }
-            field_read        = array_t<real_t***>(name, nx1_r, nx2_r, nx3_r);
-            auto field_read_h = Kokkos::create_mirror_view(field_read);
-            reader.Get(fieldVar, field_read_h.data(), adios2::Mode::Sync);
-            Kokkos::deep_copy(field_read, field_read_h);
-
-            Kokkos::parallel_for(
-              "check",
-              CreateRangePolicy<Dim::_3D>({ 0, 0, 0 }, { nx1_r, nx2_r, nx3_r }),
-              Lambda(index_t i1, index_t i2, index_t i3) {
-                if (not cmp::AlmostEqual(field_read(i1, i2, i3),
-                                         field(i1 * dwn1 + i1min,
-                                               i2 * dwn2 + i2min,
-                                               i3 * dwn3 + i3min,
-                                               cntr))) {
-                  Kokkos::printf(
-                    "\n:::::::::::::::\nfield_read(%ld, %ld, %ld) = %f != "
-                    "field(%ld, %ld, %ld, %d) = %f\n:::::::::::::::\n",
-                    i1,
-                    i2,
-                    i3,
-                    field_read(i1, i2, i3),
-                    i1 * dwn1 + i1min,
-                    i2 * dwn2 + i2min,
-                    i3 * dwn3 + i3min,
-                    cntr,
-                    field(i1 * dwn1 + i1min, i2 * dwn2 + i2min, i3 * dwn3 + i3min, cntr));
-                  raise::KernelError(HERE, "Field is not read correctly");
-                }
-              });
-          } else {
-            raise::Error("Field not found", HERE);
+            ++cntr;
           }
-          ++cntr;
+          reader.EndStep();
         }
-        reader.EndStep();
+        reader.Close();
       }
-      reader.Close();
     }
   } catch (std::exception& e) {
     std::cerr << e.what() << std::endl;
diff --git a/src/output/utils/attr_writer.h b/src/output/utils/attr_writer.h
index 41b64fb75..4e0c0c87a 100644
--- a/src/output/utils/attr_writer.h
+++ b/src/output/utils/attr_writer.h
@@ -12,7 +12,7 @@
 #define OUTPUT_UTILS_ATTR_WRITER_H
 
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 
 #include <any>
 #include <functional>
diff --git a/src/output/writer.cpp b/src/output/writer.cpp
index 64d0f0810..ff18a0364 100644
--- a/src/output/writer.cpp
+++ b/src/output/writer.cpp
@@ -10,7 +10,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 
 #if defined(MPI_ENABLED)
   #include "arch/mpi_aliases.h"
@@ -26,11 +26,9 @@ namespace out {
 
   void Writer::init(adios2::ADIOS*     ptr_adios,
                     const std::string& engine,
-                    const std::string& title,
-                    bool               use_separate_files) {
-    m_separate_files = use_separate_files;
-    m_engine         = fmt::toLower(engine);
-    p_adios          = ptr_adios;
+                    const std::string& title) {
+    m_engine = fmt::toLower(engine);
+    p_adios  = ptr_adios;
 
     raise::ErrorIf(p_adios == nullptr, "ADIOS pointer is null", HERE);
 
@@ -48,9 +46,8 @@ namespace out {
     m_trackers.insert({ type, tools::Tracker(type, interval, interval_time) });
   }
 
-  auto Writer::shouldWrite(const std::string& type,
-                           timestep_t         step,
-                           simtime_t          time) -> bool {
+  auto Writer::shouldWrite(const std::string& type, timestep_t step, simtime_t time)
+    -> bool {
     if (m_trackers.find(type) != m_trackers.end()) {
       return m_trackers.at(type).shouldWrite(step, time);
     } else {
@@ -414,41 +411,35 @@ namespace out {
       path_t filename;
 
       const std::string ext = (m_engine == "hdf5") ? "h5" : "bp";
-      if (m_separate_files) {
-        std::string mode_str;
-        if (write_mode == WriteMode::Fields) {
-          mode_str = "fields";
-        } else if (write_mode == WriteMode::Particles) {
-          mode_str = "particles";
-        } else if (write_mode == WriteMode::Spectra) {
-          mode_str = "spectra";
-        } else {
-          raise::Fatal("Unknown write mode", HERE);
-        }
-        CallOnce(
-          [](auto&& main_path, auto&& mode_path) {
-            const path_t main { main_path };
-            const path_t mode { mode_path };
-            if (!std::filesystem::exists(main_path)) {
-              std::filesystem::create_directory(main_path);
-            }
-            if (!std::filesystem::exists(main_path / mode_path)) {
-              std::filesystem::create_directory(main_path / mode_path);
-            }
-          },
-          m_root,
-          mode_str);
-#if defined(MPI_ENABLED)
-        MPI_Barrier(MPI_COMM_WORLD);
-#endif
-        filename = m_root / path_t(mode_str) /
-                   fmt::format("%s.%08lu.%s", mode_str.c_str(), tstep, ext.c_str());
-        m_mode = adios2::Mode::Write;
+      std::string       mode_str;
+      if (write_mode == WriteMode::Fields) {
+        mode_str = "fields";
+      } else if (write_mode == WriteMode::Particles) {
+        mode_str = "particles";
+      } else if (write_mode == WriteMode::Spectra) {
+        mode_str = "spectra";
       } else {
-        filename = fmt::format("%s.%s", m_root.c_str(), ext.c_str());
-        m_mode   = std::filesystem::exists(filename) ? adios2::Mode::Append
-                                                     : adios2::Mode::Write;
+        raise::Fatal("Unknown write mode", HERE);
       }
+      CallOnce(
+        [](auto&& main_path, auto&& mode_path) {
+          const path_t main { main_path };
+          const path_t mode { mode_path };
+          if (!std::filesystem::exists(main_path)) {
+            std::filesystem::create_directory(main_path);
+          }
+          if (!std::filesystem::exists(main_path / mode_path)) {
+            std::filesystem::create_directory(main_path / mode_path);
+          }
+        },
+        m_root,
+        mode_str);
+#if defined(MPI_ENABLED)
+      MPI_Barrier(MPI_COMM_WORLD);
+#endif
+      filename = m_root / path_t(mode_str) /
+                 fmt::format("%s.%08lu.%s", mode_str.c_str(), tstep, ext.c_str());
+      m_mode   = adios2::Mode::Write;
       m_writer = m_io.Open(filename, m_mode);
       m_writer.BeginStep();
       m_writer.Put(m_io.InquireVariable<timestep_t>("Step"), &tstep);
diff --git a/src/output/writer.h b/src/output/writer.h
index 4fe0c194f..1003e932c 100644
--- a/src/output/writer.h
+++ b/src/output/writer.h
@@ -17,7 +17,7 @@
 #include "output/spectra.h"
 
 #include <adios2.h>
-#include <adios2/cxx11/KokkosView.h>
+#include <adios2/cxx/KokkosView.h>
 
 #if defined(MPI_ENABLED)
   #include <mpi.h>
@@ -35,8 +35,6 @@ namespace out {
     adios2::Engine m_writer;
     adios2::Mode   m_mode { adios2::Mode::Write };
 
-    bool m_separate_files;
-
     // global shape of the fields array to output
     std::vector<ncells_t> m_flds_g_shape;
     // local corner of the fields array to output
@@ -74,7 +72,7 @@ namespace out {
 
     Writer(Writer&&) = default;
 
-    void init(adios2::ADIOS*, const std::string&, const std::string&, bool);
+    void init(adios2::ADIOS*, const std::string&, const std::string&);
 
     void setMode(adios2::Mode);